rupert 0.0.1 → 0.0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 41a2074b3a0e08e088990219f5659323705498e3
-  data.tar.gz: 810e02415872bb758efa3b109f70e5d264f8455f
+  metadata.gz: 8a0baa0b545ca0c693abd38c0c23e6631d441982
+  data.tar.gz: f786fc3a79ef710b65d0c8c63bfc652368b21c58
 SHA512:
-  metadata.gz: 3b351ae5740f728a267a41afc8a474921aaf072d3141209cc86d743e4011ebe223adb5c6fb45db7c3bb29d4b67d5cbae99d6748c564264f97b2160508db7f626
-  data.tar.gz: 1585d64649df3e91617ddb3b4b88464d8a4f3aac419e18c862ee1009de1915554502be5c793257d79d4a0f39164008d98170bb79bbe59787f3a9ff75e2eba24f
+  metadata.gz: c8757b87031ea4a3744a80bb0b2664f606c7e1f5b49aa77ae77f9a1fb32b6dd8fc806dc8016b3ef3da125aac8dad3bcf294df4825f98d6b8cbea1e2128371006
+  data.tar.gz: 09a9460c7382da48467712467a059e6c9518b65c1693073715f1181d3f845be5e2dab03166b12102ce5fd215f1e20e05a53143ed83810d8e53396dbb54511579

data/Changelog.md

@@ -0,0 +1,15 @@
+# Changelog
+
+## 0.0.2
+
+* First pieces of metadata fetched from RPM header structure:
+  * package name
+  * list of installed files
+  * installed package size
+* Major design improvements
+
+## 0.0.1
+
+* Read information from RPM lead section
+* Read MD5 checksum information from RPM signature structure
+* Perform basic (non-crypto) package integrity verification

data/README.md

@@ -1,3 +1,4 @@
+[![Gem Version](https://badge.fury.io/rb/rupert.png)](http://badge.fury.io/rb/rupert)
 [![Build Status](https://travis-ci.org/stefanozanella/rupert.png?branch=master)](https://travis-ci.org/stefanozanella/rupert)
 [![Code Climate](https://codeclimate.com/github/stefanozanella/rupert.png)](https://codeclimate.com/github/stefanozanella/rupert)
 [![Coverage Status](https://coveralls.io/repos/stefanozanella/rupert/badge.png?branch=master)](https://coveralls.io/r/stefanozanella/rupert?branch=master)
@@ -23,6 +24,8 @@ Or install it yourself as:
 
 ## Usage
 
+### Parsing an RPM
+
 You can read an RPM simply with:
 
     rpm = Rupert::RPM.load('rpm-4.8.0-32.el6.x86_64.rpm')
@@ -33,6 +36,23 @@ or just check if a specific file is an RPM with:
 
 (note that loading a file that is not an RPM generates an exception)
 
+### Verifying RPM for corruption
+
+You can verify if an RPM is corrupted after loading it with:
+
+    rpm.intact?
+
+Note that this only verifies if the MD5 stored in RPM metadata corresponds to
+the MD5 calculated over the content and metadata itself. It doesn't provide any
+warranty that the packages has been _maliciously_ altered. For this, you need
+to check package _signature_.
+
+### List of installed files
+
+The list of installed files is returned as an array of absolute filenames with:
+
+    rpm.filenames
+
 ## Contributing
 
 1. Fork it
@@ -40,3 +60,7 @@ or just check if a specific file is an RPM with:
 3. Commit your changes (`git commit -am 'Add some feature'`)
 4. Push to the branch (`git push origin my-new-feature`)
 5. Create new Pull Request
+
+## Changelog
+
+See [Changelog.md](Changelog.md)

data/TODO.md

@@ -26,14 +26,20 @@
 * Remember that signature is not mandatory in RPM!
 * It looks like size is also a form of signature, in the sense that RPM uses
   the stored value to check actual size of header + payload (or did I
-  understood wrong?).
+  understood wrong?) -> make integrity + auth verification check everything at
+  once?.
 * I18N ???
+* Improve Index robustness against null values of store and entries, and for
+  missing tags -> decide what to return. Also improve robustness for invalid
+  types (cryptic metaprogramming errors are returned as of now).
 
 # Roadmap
 
-* Pick the entry type table. For each type, pick a meaningful header tag (like
-  name, file list, etc.) to derive a feature to be implemented. At the end, all
-  types should be correctly handled
+* Pick the entry type table. For each type, pick a meaningful (mandatory may be
+* easy - see below) header tag (like
+  name, file list, etc.) to derive a feature to be implemented. At the end,
+  (almost) all types should be correctly handled
 * Decide a sensible behaviour for missing mandatory tags. Then, pick all
   mandatory header tags and build a feature for them if not already covered
   with previous method.
+* Decide how to handle optional tags (return nil?)

data/lib/rupert/parser.rb

@@ -1,5 +1,6 @@
 require 'rupert/rpm/lead'
-require 'rupert/rpm/signature'
+require 'rupert/rpm/index'
+require 'rupert/rpm/entry'
 
 module Rupert
   class Parser
@@ -11,49 +12,65 @@ module Rupert
       # TODO Fit to current design (i.e. no parsing in Lead c'tor?)
       lead = RPM::Lead.new(@raw_io)
 
-      entry_count, store_size = parse_header
-      entries = parse_entries(entry_count)
+      signature = signature_from(parse_index(@raw_io))
 
-      store = parse_store(store_size)
-      content = parse_content
+      # TODO I'd like to get rid of this duplication, but still don't know how.
+      # Ideally, raw signed content should be available from both archive and
+      # header, and concatenated to calculate checksum.
+      content = parse_content @raw_io
+      @raw_io.seek(-content.length, IO::SEEK_CUR)
 
-      signature = RPM::Signature.new(RPM::Signature::Index.new(entries, store))
+      header = header_from(parse_index(@raw_io))
 
-      RPM.new(lead, signature, content)
+      RPM.new(lead, signature, content, header)
     end
 
     private
 
-    def parse_header
+    def header_from(index)
+      RPM::Header.new index
+    end
+
+    def signature_from(index)
+      RPM::Signature.new index
+    end
+
+    def parse_header(raw_io)
       header_size = 16
       header_format =  "@8NN"
 
-      @raw_io.read(header_size).unpack(header_format)
+      raw_io.read(header_size).unpack(header_format)
     end
 
-    def parse_entries(count)
-      entry_size = 16
-      entry_format = "NNNN"
+    def parse_store(size, raw_io)
+      StringIO.new(raw_io.read(nearest_multiple(8, size)))
+    end
 
-      entries = Hash.new
-      count.times do
-        tag, type, offset, count = @raw_io.read(entry_size).unpack(entry_format)
-        entry = RPM::Signature::Entry.new tag, type, offset, count
-        entries[entry.tag] = entry
+    def parse_content(raw_io)
+      raw_io.read.force_encoding(Encoding::ASCII_8BIT)
+    end
+
+    def parse_index(raw_io)
+      index = RPM::Index.new
+
+      entry_count, store_size = parse_header(raw_io)
+      entry_count.times do
+        index.add parse_entry(raw_io)
       end
 
-      entries
-    end
+      index.store = parse_store(store_size, raw_io)
 
-    def parse_store(size)
-      RPM::Signature::Store.new(StringIO.new(@raw_io.read(nearest_multiple(size, 8))))
+      index
     end
 
-    def parse_content
-      @raw_io.read
+    def parse_entry(raw_io)
+      entry_size = 16
+      entry_format = "NNNN"
+
+      RPM::Entry.new(*raw_io.read(entry_size).unpack(entry_format))
     end
 
-    def nearest_multiple(size, modulo)
+    def nearest_multiple(modulo, size)
       (size / modulo.to_f).ceil * modulo
     end
   end

data/lib/rupert/rpm.rb

@@ -2,6 +2,7 @@ require 'rupert/errors'
 require 'rupert/parser'
 require 'rupert/rpm/lead'
 require 'rupert/rpm/signature'
+require 'rupert/rpm/header'
 
 require 'base64'
 
@@ -26,7 +27,7 @@ module Rupert
       # Tells whether given filename points to a valid RPM or not.
       #
       # @param filename [String] filename to inspect
-      # @return `true` if file starts with the correct magic header
+      # @return +true+ if file starts with the correct magic header
       def rpm?(filename)
         Lead.new(File.open(filename, 'r')).rpm?
       end
@@ -35,37 +36,39 @@ module Rupert
     # Initialize the RPM object, given its components.
     #
     # This method is not intended to be used to instantiate RPM objects
-    # directly. Instead, use Rupert::RPM::load for a more straightforward
+    # directly. Instead, use {Rupert::RPM.load} for a more straightforward
     # alternative.
     #
     # @param lead [Rupert::RPM::Lead] RPM lead section
-    # @param signature [Rupert::RPM::Signature] RPM signature section
+    # @param signature [Rupert::RPM::Signature] RPM signature information
     # @param content [String] Raw content found after the signature structure
-    def initialize(lead, signature, content)
+    # @param header [Rupert::RPM::Header] RPM header holding package metadata
+    def initialize(lead, signature, content, header)
       @lead = lead
       @signature = signature
       @content = content
+      @header = header
     end
 
     # RPM version used to encode the package.
     #
-    # @return [String] the RPM version in `<major>.<minor>` format
+    # @return [String] the RPM version in +<major>.<minor>+ format
     def rpm_version
       @lead.rpm_version
     end
 
-    # @return `true` if the RPM is of type binary, `false` otherwise
+    # @return +true+ if the RPM is of type binary, +false+ otherwise
     def binary?
       @lead.binary_type?
     end
 
-    # @return `true` if the RPM is of type source, `false` otherwise
+    # @return +true+ if the RPM is of type source, +false+ otherwise
     def source?
       @lead.source_type?
     end
 
-    # Which architecture the package was built for, e.g. `i386/x86_64` or
-    # `arm`
+    # Which architecture the package was built for, e.g. +i386/x86_64+ or
+    # +arm+
     #
     # @return [String] package architecture name
     def rpm_arch
@@ -74,20 +77,20 @@ module Rupert
 
     # Full package name
     #
-    # @return [String] package name in the form <name>-<version>-<rev>.<suffix>
+    # @return [String] package name in the form +<name>-<version>-<rev>.<suffix>+
     def name
-      @lead.name
+      @header.name
     end
 
     # OS for which the package was built
     #
-    # @return [String] as defined in /usr/lib/rpm/rpmrc under the canonical OS
+    # @return [String] as defined in _/usr/lib/rpm/rpmrc_ under the canonical OS
     #         names section
     def os
       @lead.os
     end
 
-    # @return `true` if the package is signed, `false` otherwise
+    # @return +true+ if the package is signed, +false+ otherwise
     def signed?
       @lead.signed?
     end
@@ -95,10 +98,10 @@ module Rupert
     # MD5 checksum stored in the package (base64 encoded). To be used to check
     # package integrity.
     #
-    # NOTE: This is not the MD5 of the whole package; rather, the digest is
+    # *NOTE*: This is not the MD5 of the whole package; rather, the digest is
     # calculated over the header and payload, leaving out the lead and the
-    # signature header. I.e., running `md5sum <myrpm>` won't held the same
-    # result as `Rupert::RPM.load('<myrpm>').md5`.
+    # signature header. I.e., running +md5sum <myrpm>+ won't held the same
+    # result as +Rupert::RPM.load('<myrpm>').md5+.
     #
     # @return [String] Base64-encoded MD5 checksum of package's header and
     #         payload, stored in the RPM itself
@@ -109,10 +112,36 @@ module Rupert
     # Verifies package integrity. Compares MD5 checksum stored in the package
     # with checksum calculated over header(s) and payload (archive).
     #
-    # @return `true` if package is intact, `false` if package (either stored MD5 or
+    # @return +true+ if package is intact, +false+ if package (either stored MD5 or
     # payload) is corrupted
     def intact?
-      @signature.verify_checksum(@content)      
+      @signature.md5 == Digest::MD5.digest(@content)
+    end
+
+    # Package uncompressed size.
+    #
+    # This is the size (in bytes) of the uncompressed archive, or if you
+    # prefer, package's installed size.
+    #
+    # *NOTE*: if reading a package built with native +rpmbuild+, this number
+    # (which is stored in the RPM itself) might not be precise, as
+    # this[http://rpm5.org/community/rpm-devel/2689.html] thread explains. 
+    #
+    # @return [Fixnum] package uncompressed size (bytes)
+    def uncompressed_size
+      @header.uncompressed_size
+    end
+
+    # List of installed files (full paths).
+    #
+    # @return [Array] array of +String+, with entries corresponding to 
+    #         absolute filenames
+    def filenames
+      @header.dirindexes.map { |idx|
+        @header.dirnames[idx]
+      }.zip(@header.basenames).map { |dir, name|
+        File.join(dir, name)
+      }
     end
   end
 end

data/lib/rupert/rpm/entry.rb

@@ -0,0 +1,127 @@
+module Rupert
+  class RPM
+    class Entry
+      # Initializes a new index entry.
+      #
+      # @param tag [String] 4 byte entry tag (semantic data type)
+      # @param type [String] 4 byte entry data format
+      # @param offset [String] 4 byte pointer to data in the index store
+      # @param count [String] 4 byte number of data items held by the entry
+      def initialize(tag, type, offset, count)
+        @tag, @type, @offset, @count = tag, type, offset, count
+      end
+
+      attr_accessor :tag
+
+      # Fetches referenced data from a store.
+      #
+      # An entry contains only information about a piece of data, but not the
+      # actual data. In essence, it behaves more or less like a pointer,
+      # which contains the address at which data is available.
+      #
+      # This method behaves exactly like pointer dereference, i.e. it returns
+      # the actual data at the address held by the entry itself. In addition,
+      # data is not returned in raw form; instead, it is returned in the
+      # format declared in the entry itself. The available RPM formats are the
+      # following:
+      #
+      # * NULL
+      # * CHAR
+      # * INT8
+      # * INT16
+      # * INT32
+      # * INT64 (not supported yet even in rpmlib?)
+      # * STRING
+      # * BIN
+      # * STRING_ARRAY
+      # * I18NSTRING
+      #
+      # which are in turn mapped in Ruby with:
+      #
+      # * +nil+
+      # * (+Array+ of) +String+ of length 1
+      # * (+Array+ of) +Fixnum+
+      # * (+Array+ of) +Fixnum+
+      # * (+Array+ of) +Fixnum+
+      # * (+Array+ of) +Fixnum+/+Bignum+
+      # * +String+ of arbitrary length
+      # * +String+ of arbitrary length, 8-bit ASCII encoded
+      # * +Array+ of +String+
+      # * +Array+ of +String+
+      #
+      # *NOTE*: The store is sought to retrieve data. Do not make any
+      # assumptions on IO's pointer state after method call. If you need to
+      # perform subsequent operations on the IO that require a particular
+      # cursor position, seek the IO to wanted position before performing
+      # the operation.
+      #
+      # @param store [IO] raw data store, represented by an IO object
+      # @return [Object] data referenced by this entry, in whatever format
+      #         the entry prescribe
+      def resolve(store)
+        store.seek(@offset, IO::SEEK_SET)
+        read_and_convert(@type, store)
+      end
+
+      private
+
+      # :nodoc: Null byte used to indicate string termination
+      NULL_CHAR = "\x00".force_encoding(Encoding::ASCII_8BIT)
+
+      # :nodoc: Map of numerical entry types to parsing functions.
+      #
+      # NOTE: It turns out that distinguishing between strings and string
+      # arrays is irrelevant (at least with this implementation), since for
+      # every data type, if the count is 1 data is not wrapped in an array.
+      TYPE_MAP = {
+        4 => :int32,
+        6 => :string,
+        7 => :binary,
+        8 => :string
+      }
+
+      # :nodoc: Reads given type of data from given store
+      def read_and_convert(type, store)
+        method(TYPE_MAP[type]).call(store)
+      end
+
+      # :nodoc: Returns a list of integers, or a single element if count is 1
+      def int32(store)
+        first_or(array_of(lambda { one_int_32(store) }))
+      end
+
+      # :nodoc: Returns an array with given number of null-terminated strings,
+      # or a single string if count is 1
+      def string(store)
+        first_or(array_of(lambda { one_string(store) }))
+      end
+
+      def binary(store)
+        store.read(@count)
+      end
+
+      # :nodoc: Parses a single int32 from the store
+      def one_int_32(store)
+        store.read(4).unpack("N").first
+      end
+
+      # :nodoc: Parses a null-terminated string, without the trailing null
+      # character.
+      def one_string(store)
+        store.gets(NULL_CHAR).chomp(NULL_CHAR)
+      end
+
+      # :nodoc: Strips off array if it contains only one element
+      def first_or(ary)
+        ary.length == 1 ? ary.first : ary
+      end
+
+      # :nodoc: Builds an array of count elements parsed used given function
+      def array_of(parse_fun)
+        (1..@count).inject([]) { |ary|
+          ary << parse_fun.call
+        }
+      end
+    end
+  end
+end

data/lib/rupert/rpm/header.rb

@@ -0,0 +1,55 @@
+module Rupert
+  class RPM
+    class Header
+      NAME_TAG      = 1000.freeze
+      SIZE_TAG      = 1009.freeze
+      DIRINDEXES_TAG = 1116.freeze
+      BASENAMES_TAG = 1117.freeze
+      DIRNAMES_TAG  = 1118.freeze
+
+      # Creates a new header.
+      #
+      # @param index [Rupert::RPM::Index] index structure holding actual
+      #              information
+      def initialize(index)
+        @index = index
+      end
+
+      # Package name.
+      #
+      # @return [String]
+      def name
+        @index.get(NAME_TAG)
+      end
+
+      # Package uncompressed size (bytes).
+      #
+      # @return [Fixnum]
+      def uncompressed_size
+        @index.get(SIZE_TAG)
+      end
+
+      # Package files basename list.
+      #
+      # @return [Array] of +String+
+      def basenames
+        @index.get(BASENAMES_TAG)
+      end
+
+      # Installed directory list.
+      #
+      # @return [Array] of +String+
+      def dirnames
+        @index.get(DIRNAMES_TAG)
+      end
+
+      # Map between basenames and relative directories.
+      #
+      # @return [Array] of +Fixnum+, where each number represents an index in
+      # the +dirnames+ array
+      def dirindexes
+        @index.get(DIRINDEXES_TAG)
+      end
+    end
+  end
+end

data/lib/rupert/rpm/index.rb

@@ -0,0 +1,51 @@
+require 'rupert/rpm/entry'
+
+module Rupert
+  class RPM
+    class Index
+      attr_writer :store
+
+      # Initializes a new signature index, given the header's entries and the
+      # store containing actual data.
+      #
+      # @param entries [Array] a list of
+      #                {Rupert::RPM::Entry}, or optionally a
+      #                single {Rupert::RPM::Entry} not included in
+      #                any array
+      # @param store [IO] raw store containing data pointed by entries
+      def initialize(entries=[], store=nil)
+        @entries = index list_of entries
+        @store = store
+      end
+
+      # Retrieves data pointed by given tag.
+      #
+      # @param tag [Fixnum] data type
+      # @return [Object] data associated to given tag, with variable format
+      #         depending on how it's stored (see
+      #         {Rupert::RPM::Entry#resolve})
+      def get(tag)
+        @entries[tag].resolve(@store)
+      end
+
+      # Adds an entry to the index.
+      #
+      # @param entry [Rupert::RPM::Entry] new entry to add to the index
+      def add(entry)
+        @entries[entry.tag] = entry
+      end
+
+      private
+
+      # :nodoc: Force returned object to be an array
+      def list_of(maybe_an_array)
+        [maybe_an_array].flatten
+      end
+
+      # :nodoc: Given an array of entries, index them by tag
+      def index(entries)
+        Hash[entries.collect { |entry| [entry.tag, entry] }]
+      end
+    end
+  end
+end

data/lib/rupert/rpm/lead.rb

@@ -5,7 +5,7 @@ module Rupert
       LEAD_LENGTH = 96.freeze # byte
 
       # The magic header that identifies an RPM beyond a shadow of a doubt, as
-      # every good RPM starts with hex `ed ab ee db`.
+      # every good RPM starts with hex +ed ab ee db+.
       MAGIC = "\xed\xab\xee\xdb".force_encoding(Encoding::ASCII_8BIT).freeze
 
       # RPM of type binary
@@ -25,12 +25,12 @@ module Rupert
       # Only valid and recognized signature type
       SIGNATURE_TYPE_HEADER = 5.freeze
 
-      # Chomps given IO, producing a `Lead` object and returning the remaining
+      # Chomps given IO, producing a {Lead} object and returning the remaining
       # part for subsequent processing.
       #
       # Lead data is expected to begin at IO start, so returned scrap is
       # basically the input IO without its first
-      # `Rupert::RPM::Lead::LEAD_LENGTH` bytes.
+      # {Rupert::RPM::Lead::LEAD_LENGTH} bytes.
       #
       # @param io [IO] IO object containing lead data at its start, possibly
       #           with additional bytes at the end 
@@ -73,24 +73,24 @@ module Rupert
 
       # Tells if the file is recognized as an RPM or not
       #
-      # @return `true` if magic number is found at lead's start, `false`
+      # @return +true+ if magic number is found at lead's start, +false+
       #          otherwise
       def rpm?
         @magic == MAGIC
       end
 
-      # @return `true` if lead reports RPM as of binary type
+      # @return +true+ if lead reports RPM as of binary type
       def binary_type?
         @type == TYPE_BINARY
       end
 
-      # @return `true` if lead reports RPM as of source type
+      # @return +true+ if lead reports RPM as of source type
       def source_type?
         @type == TYPE_SOURCE
       end
 
       # The architecture the package was built for. A list of supported
-      # architectures can be found in `/usr/lib/rpm/rpmrc` on RedHat based
+      # architectures can be found in _/usr/lib/rpm/rpmrc_ on RedHat based
       # systems.
       #
       # @return [String] a string representing the architecture name(s)
@@ -107,12 +107,12 @@ module Rupert
 
       # OS for which the package was built
       #
-      # @return [String] OS canonical name as defined in `/usr/lib/rpm/rpmrc`
+      # @return [String] OS canonical name as defined in _/usr/lib/rpm/rpmrc_
       def os
         @@os_map[@osnum]
       end
 
-      # @return `true` if the RPM is recognized as being signed, `false` otherwise
+      # @return +true+ if the RPM is recognized as being signed, +false+ otherwise
       def signed?
         @signature_type == SIGNATURE_TYPE_HEADER
       end
@@ -129,7 +129,7 @@ module Rupert
       private
 
       # :nodoc
-      # The format string passed to `unpack` to parse the lead
+      # The format string passed to +unpack+ to parse the lead
       LEAD_FORMAT = "A4CCnnZ66nna16".freeze
 
       # :nodoc

data/lib/rupert/rpm/signature.rb

@@ -1,5 +1,3 @@
-require 'rupert/rpm/signature/index'
-
 module Rupert
   class RPM
     class Signature
@@ -21,23 +19,6 @@ module Rupert
       def md5
         @index.get MD5_TAG
       end
-
-      # Verifies if stored MD5 checksum corresponds to digest calculated over
-      # given content.
-      #
-      # @return `true` if stored MD5 checksum corresponds to MD5 calculated
-      #         over given content, `false` otherwise
-      def verify_checksum(content)
-        md5 == md5_checksum(content)
-      end
-
-      private
-
-      # :nodoc
-      # MD5 checksum of given string
-      def md5_checksum(str)
-        Digest::MD5.digest(str)
-      end
     end
   end
 end

data/lib/rupert/version.rb

@@ -1,3 +1,3 @@
 module Rupert
-  VERSION = "0.0.1"
+  VERSION = "0.0.2"
 end

data/rubygems-stefanozanella.crt

@@ -0,0 +1,20 @@
+-----BEGIN CERTIFICATE-----
+MIIDQDCCAiigAwIBAgIBADANBgkqhkiG9w0BAQUFADBGMRgwFgYDVQQDDA96YW5l
+bGxhLnN0ZWZhbm8xFTATBgoJkiaJk/IsZAEZFgVnbWFpbDETMBEGCgmSJomT8ixk
+ARkWA2NvbTAeFw0xMzA4MDcxOTA2MDZaFw0xNDA4MDcxOTA2MDZaMEYxGDAWBgNV
+BAMMD3phbmVsbGEuc3RlZmFubzEVMBMGCgmSJomT8ixkARkWBWdtYWlsMRMwEQYK
+CZImiZPyLGQBGRYDY29tMIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEA
+2JCnJCnjjs62MR/Tw/4WgSG42ruiCEqXV1ECMsXymHPE8xyHkYAwLXvBRzOkZ/IA
+puJ1XhScduMRcUuE0ZPA5N2HBZI0WsmyyNTYBjOob8m0SNInoRZfIMloj3D8QzB7
+/6G5HLMWNx60JEpIDgfXvIuSRKNKQ0/0+/G/H4COgj72pd3F4dYltvx+mSwPRq7Q
+MdZsK3T5Q3d4eLBY1VSlJpq0wkwdEWTXAhR0Mfmbn1D8m9IhJfubgXuXVBY4OPO8
+KAF/wWqTkzA6guVQlSKdZR4vwms7OpeFkotnivBKa6JwUQSXO8AZEyy53V8cSYDu
+dbaFi53YbEwOWSMQnW8/kQIDAQABozkwNzAdBgNVHQ4EFgQUcBKkmJAvSTKfDf7z
+LEu1wE+Rk+swCQYDVR0TBAIwADALBgNVHQ8EBAMCBLAwDQYJKoZIhvcNAQEFBQAD
+ggEBAMeqfk1l4Y0iZ8jNiu0afcQ60DVqBkRtrT/rsZEqGsdOw11bntOE4yWpo4Kd
+Y0C/kYrVQ/mIN7IGKbCSjES3aYdQftV9SRW77FA25m2KXRbnEYtJDUX35gAqSdRY
+9IiYivsMq2dr70eKPNFrFOwWvmwhcGyEG8EDvYoXWllke7RGz1Dn/AZx6jPnShO+
+0ru4OXsM9++md3sGXIugEFNygvo2/1yQoTe6+XiBocS+pWsJd6JZBfkxPRT4Dz4H
+RigBD0E3/t/ABjCXkmqwp5gnAZmP8JiVUkn8rp5E0FXvC8T7nsPs2TW/TAmUV6rN
+hK25FX8YWgT9fD9y3PpWjiYcrCo=
+-----END CERTIFICATE-----

data/rupert.gemspec

@@ -31,4 +31,7 @@ Gem::Specification.new do |spec|
   spec.description = %s{
     Rupert allows to manipulate RPM files independently from availability of rpmlib.
   }
+
+  spec.signing_key = File.expand_path "~/.ssh/rubygems-stefanozanella.key"
+  spec.cert_chain  = ["rubygems-stefanozanella.crt"]
 end

data/test/end_to_end/rpm_test.rb

@@ -20,6 +20,22 @@ describe Rupert::RPM do
     }.must_raise Rupert::NotAnRPM
   end
 
+  it "tells the package's name" do
+    rpm.name.must_equal "rpm"
+  end
+
+  it "tells the package uncompressed size (in bytes)" do
+    rpm.uncompressed_size.must_equal 2031240
+  end
+
+  it "tells the full name of the files contained in the package" do
+    rpm.filenames.length.must_equal 0x8c
+
+    rpm.filenames.must_include "/bin/rpm"
+    rpm.filenames.must_include "/usr/share/doc/rpm-4.8.0/ChangeLog.bz2"
+    rpm.filenames.must_include "/var/lib/rpm/__db.009"
+  end
+
   it "knows which version of RPM the file is" do
     rpm.rpm_version.must_equal "3.0"
   end
@@ -29,15 +45,11 @@ describe Rupert::RPM do
   end
 
   it "tells if the file is a binary or source RPM" do
-    assert binary_rpm.binary?, "failed to recognize RPM as binary"
-    refute binary_rpm.source?, "RPM misrecognized as of source type"
+    binary_rpm.must_be :binary?
+    binary_rpm.wont_be :source?
 
-    assert source_rpm.source?, "failed to recognize RPM as source"
-    refute source_rpm.binary?, "RPM misrecognized as of binary type"
-  end
-
-  it "tells the package's name" do
-    rpm.name.must_equal "rpm-4.8.0-32.el6"
+    source_rpm.must_be :source?
+    source_rpm.wont_be :binary?
   end
 
   it "tells the operating system for which the package has been built" do
@@ -45,6 +57,6 @@ describe Rupert::RPM do
   end
 
   it "tells if package is signed" do
-    assert rpm.signed?, "expected the package to be signed, but it was not"
+    rpm.must_be :signed?
   end
 end

data/test/test_helper.rb

@@ -24,6 +24,19 @@ def ascii(string)
   string.force_encoding(Encoding::ASCII_8BIT)
 end
 
+# Returns a random binary string (8-bit ASCII encoding) of given length
+def random_ascii(size)
+  require 'securerandom'
+  ascii(SecureRandom.random_bytes(size))
+end
+
+# Returns the (strict) base64 representation of given string
+def base64(string)
+  require 'base64'
+
+  Base64.strict_encode64(string)
+end
+
 # Pads a string with nulls to fill given length
 def pad(string, length)
   ("%-#{length}.#{length}s" % string).gsub(" ", "\x00")

data/test/unit/rpm/entry_test.rb

@@ -0,0 +1,48 @@
+require 'test_helper'
+
+describe Rupert::RPM::Entry do
+  describe "fetching binary data" do
+    let(:store) { io(ascii("\x00\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0a")) }
+    let(:entry) { Rupert::RPM::Entry.new(nil, 7, 4, 5) }
+
+    it "fetches binary data which length and position is given by the entry" do
+      entry.resolve(store).must_equal ascii("\x04\x05\x06\x07\x08")
+    end
+  end
+
+  describe "fetching a single string" do
+    let(:store) { io(ascii("\x00\x01Null-terminated string.\x00LOLTHISCRAP")) }
+    let(:entry) { Rupert::RPM::Entry.new(nil, 6, 2, 1) }
+
+    it "retrieves all chars starting from entry offset until it encounters `\x00`" do
+      entry.resolve(store).must_equal "Null-terminated string."
+    end
+  end
+
+  describe "fetching an array of strings" do
+    let(:store) { io(ascii("One\x00Two\x00Three")) }
+    let(:entry) { Rupert::RPM::Entry.new(nil, 8, 0, 3) }
+
+    it "retrieves all chars starting from entry offset until it encounters `\x00`" do
+      entry.resolve(store).must_equal [ "One", "Two", "Three" ]
+    end
+  end
+
+  describe "fetching a single 32-bit integer" do
+    let(:store) { io(ascii("Somecrap\x00\x12\x34\x56\x78Tail content")) }
+    let(:entry) { Rupert::RPM::Entry.new(nil, 4, 9, 1) }
+
+    it "successfully retrieves a single 32-bit integer" do
+      entry.resolve(store).must_equal 0x12345678
+    end
+  end
+
+  describe "fetching an array of 32-bit integer" do
+    let(:store) { io(ascii("\x11\x11\x11\x11\x22\x22\x22\x22\x33\x33\x33\x33")) }
+    let(:entry) { Rupert::RPM::Entry.new(nil, 4, 0, 3) }
+
+    it "successfully retrieves the given number of 32-bit integers" do
+      entry.resolve(store).must_equal [ 0x11111111, 0x22222222, 0x33333333 ]
+    end
+  end
+end

data/test/unit/rpm/header_test.rb

@@ -0,0 +1,42 @@
+require 'test_helper'
+
+describe Rupert::RPM::Header do
+  let(:name_tag)       { Rupert::RPM::Header::NAME_TAG }
+  let(:size_tag)       { Rupert::RPM::Header::SIZE_TAG }
+  let(:basenames_tag)  { Rupert::RPM::Header::BASENAMES_TAG }
+  let(:dirnames_tag)   { Rupert::RPM::Header::DIRNAMES_TAG }
+  let(:dirindexes_tag) { Rupert::RPM::Header::DIRINDEXES_TAG }
+
+  let(:index)  { mock }
+  let(:header) { Rupert::RPM::Header.new index }
+  
+  it "maps RPM name stored in the header" do
+    index.expects(:get).once.with(name_tag)
+
+    header.name
+  end
+
+  it "maps RPM uncompressed size stored in the header" do
+    index.expects(:get).once.with(size_tag)
+
+    header.uncompressed_size
+  end
+
+  it "maps RPM basenames stored in the header" do
+    index.expects(:get).once.with(basenames_tag)
+
+    header.basenames
+  end
+
+  it "maps RPM dirnames stored in the header" do
+    index.expects(:get).once.with(dirnames_tag)
+
+    header.dirnames
+  end
+
+  it "maps RPM dirindexes stored in the header" do
+    index.expects(:get).once.with(dirindexes_tag)
+
+    header.dirindexes
+  end
+end

data/test/unit/rpm/index_test.rb

@@ -0,0 +1,13 @@
+require 'test_helper'
+
+describe Rupert::RPM::Index do
+  let(:entry)   { Rupert::RPM::Entry.new(3145, nil, nil, nil) }
+  let(:store)   { mock }
+  let(:index)   { Rupert::RPM::Index.new(entry, store) }
+
+  it "retrieves data associated to a specific tag" do
+    entry.expects(:resolve).once.with(store)
+
+    index.get(3145)
+  end
+end

data/test/unit/rpm/signature_test.rb

@@ -4,22 +4,10 @@ describe Rupert::RPM::Signature do
   let(:md5_signature_tag) { Rupert::RPM::Signature::MD5_TAG }
   let(:index)             { mock }
   let(:signature)         { Rupert::RPM::Signature.new(index) }
-  let(:pristine_content)  { ascii("\x01\x02\x03\x04") }
-  let(:corrupted_content) { ascii("\xf4\x04\x57\x1e") }
 
-  it "fetches the MD5 from its index" do
-    index.expects(:get).once.with(md5_signature_tag) 
+  it "maps the MD5 stored in the index" do
+    index.expects(:get).once.with(md5_signature_tag)
 
     signature.md5
   end
-
-  it "correctly verifies integrity of pristine and corrupted packages" do
-    index.stubs(:get).returns(md5(pristine_content))
-
-    assert signature.verify_checksum(pristine_content),
-           "expected pristine content to be verified correctly, but it was not"
-
-    refute signature.verify_checksum(corrupted_content),
-           "expected corrupted content not to be verified correctly, but it was"
-  end
 end

data/test/unit/rpm_test.rb

@@ -1,19 +1,47 @@
 require 'test_helper'
 
 describe Rupert::RPM do
-  let(:signature)      { mock }
-  let(:rpm)            { Rupert::RPM.new(nil, signature, signed_content) }
-  let(:signed_content) { ascii("\x01\x02\x03\x04") }
+  let(:signature)         { mock }
+  let(:header)            { mock }
+  let(:rpm)               { Rupert::RPM.new(nil, signature, signed_content, header) }
+  let(:corrupted_rpm)     { Rupert::RPM.new(nil, signature, corrupted_content, header) }
+  let(:signed_content)    { ascii("\x01\x02\x03\x04") }
+  let(:corrupted_content) { ascii("\xf4\x04\x57\x1e") }
 
-  it "exposes the MD5 digest held by the signature" do
-    signature.expects(:md5).once.returns("abc")
+  it "exposes MD5 checksum in base64 encoding" do
+    random_md5 = random_ascii(128)
+    signature.stubs(:md5).returns(random_md5)
 
-    rpm.md5
+    rpm.md5.must_equal base64(random_md5)
   end
 
-  it "asks the signature to verify content integrity" do
-    signature.expects(:verify_checksum).once.with(signed_content)
+  it "correctly verifies integrity of pristine and corrupted packages" do
+    signature.stubs(:md5).returns(md5(signed_content))
 
-    rpm.intact?
+    assert rpm.intact?,
+           "expected RPM to be intact, but it wasn't"
+
+    refute corrupted_rpm.intact?,
+           "expected RPM not to be intact, but it was"
+  end
+
+  it "exposes RPM name stored in the header" do
+    header.stubs(:name).returns("package-name")
+
+    rpm.name.must_equal("package-name")
+  end
+
+  it "exposes RPM uncompressed size stored in the header" do
+    header.stubs(:uncompressed_size).returns(1234)
+
+    rpm.uncompressed_size.must_equal 1234
+  end
+
+  it "exposes RPM basenames stored in the header" do
+    header.stubs(:basenames).returns(["file1", "file1", "file2"])
+    header.stubs(:dirnames).returns(["/dir1", "/dir2"])
+    header.stubs(:dirindexes).returns([0, 1, 0])
+
+    rpm.filenames.must_equal [ "/dir1/file1", "/dir2/file1", "/dir1/file2" ]
   end
 end

metadata

@@ -1,14 +1,35 @@
 --- !ruby/object:Gem::Specification
 name: rupert
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.0.2
 platform: ruby
 authors:
 - Stefano Zanella
 autorequire: 
 bindir: bin
-cert_chain: []
-date: 2013-08-01 00:00:00.000000000 Z
+cert_chain:
+- |
+  -----BEGIN CERTIFICATE-----
+  MIIDQDCCAiigAwIBAgIBADANBgkqhkiG9w0BAQUFADBGMRgwFgYDVQQDDA96YW5l
+  bGxhLnN0ZWZhbm8xFTATBgoJkiaJk/IsZAEZFgVnbWFpbDETMBEGCgmSJomT8ixk
+  ARkWA2NvbTAeFw0xMzA4MDcxOTA2MDZaFw0xNDA4MDcxOTA2MDZaMEYxGDAWBgNV
+  BAMMD3phbmVsbGEuc3RlZmFubzEVMBMGCgmSJomT8ixkARkWBWdtYWlsMRMwEQYK
+  CZImiZPyLGQBGRYDY29tMIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEA
+  2JCnJCnjjs62MR/Tw/4WgSG42ruiCEqXV1ECMsXymHPE8xyHkYAwLXvBRzOkZ/IA
+  puJ1XhScduMRcUuE0ZPA5N2HBZI0WsmyyNTYBjOob8m0SNInoRZfIMloj3D8QzB7
+  /6G5HLMWNx60JEpIDgfXvIuSRKNKQ0/0+/G/H4COgj72pd3F4dYltvx+mSwPRq7Q
+  MdZsK3T5Q3d4eLBY1VSlJpq0wkwdEWTXAhR0Mfmbn1D8m9IhJfubgXuXVBY4OPO8
+  KAF/wWqTkzA6guVQlSKdZR4vwms7OpeFkotnivBKa6JwUQSXO8AZEyy53V8cSYDu
+  dbaFi53YbEwOWSMQnW8/kQIDAQABozkwNzAdBgNVHQ4EFgQUcBKkmJAvSTKfDf7z
+  LEu1wE+Rk+swCQYDVR0TBAIwADALBgNVHQ8EBAMCBLAwDQYJKoZIhvcNAQEFBQAD
+  ggEBAMeqfk1l4Y0iZ8jNiu0afcQ60DVqBkRtrT/rsZEqGsdOw11bntOE4yWpo4Kd
+  Y0C/kYrVQ/mIN7IGKbCSjES3aYdQftV9SRW77FA25m2KXRbnEYtJDUX35gAqSdRY
+  9IiYivsMq2dr70eKPNFrFOwWvmwhcGyEG8EDvYoXWllke7RGz1Dn/AZx6jPnShO+
+  0ru4OXsM9++md3sGXIugEFNygvo2/1yQoTe6+XiBocS+pWsJd6JZBfkxPRT4Dz4H
+  RigBD0E3/t/ABjCXkmqwp5gnAZmP8JiVUkn8rp5E0FXvC8T7nsPs2TW/TAmUV6rN
+  hK25FX8YWgT9fD9y3PpWjiYcrCo=
+  -----END CERTIFICATE-----
+date: 2013-08-07 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -134,6 +155,7 @@ files:
 - .gitignore
 - .ruby-version
 - .travis.yml
+- Changelog.md
 - Gemfile
 - LICENSE.txt
 - README.md
@@ -143,12 +165,13 @@ files:
 - lib/rupert/errors.rb
 - lib/rupert/parser.rb
 - lib/rupert/rpm.rb
+- lib/rupert/rpm/entry.rb
+- lib/rupert/rpm/header.rb
+- lib/rupert/rpm/index.rb
 - lib/rupert/rpm/lead.rb
 - lib/rupert/rpm/signature.rb
-- lib/rupert/rpm/signature/entry.rb
-- lib/rupert/rpm/signature/index.rb
-- lib/rupert/rpm/signature/store.rb
 - lib/rupert/version.rb
+- rubygems-stefanozanella.crt
 - rupert.gemspec
 - test/end_to_end/rpm_signature_test.rb
 - test/end_to_end/rpm_test.rb
@@ -160,9 +183,10 @@ files:
 - test/fixtures/rpm-libs-4.8.0-32.el6.x86_64.rpm
 - test/fixtures/rpmdevtools-7.5-2.el6.noarch.rpm
 - test/test_helper.rb
+- test/unit/rpm/entry_test.rb
+- test/unit/rpm/header_test.rb
+- test/unit/rpm/index_test.rb
 - test/unit/rpm/lead_test.rb
-- test/unit/rpm/signature/index_test.rb
-- test/unit/rpm/signature/store_test.rb
 - test/unit/rpm/signature_test.rb
 - test/unit/rpm_test.rb
 homepage: ''
@@ -201,8 +225,9 @@ test_files:
 - test/fixtures/rpm-libs-4.8.0-32.el6.x86_64.rpm
 - test/fixtures/rpmdevtools-7.5-2.el6.noarch.rpm
 - test/test_helper.rb
+- test/unit/rpm/entry_test.rb
+- test/unit/rpm/header_test.rb
+- test/unit/rpm/index_test.rb
 - test/unit/rpm/lead_test.rb
-- test/unit/rpm/signature/index_test.rb
-- test/unit/rpm/signature/store_test.rb
 - test/unit/rpm/signature_test.rb
 - test/unit/rpm_test.rb

data/lib/rupert/rpm/signature/entry.rb

@@ -1,19 +0,0 @@
-module Rupert
-  class RPM
-    class Signature
-      class Entry
-        # Initializes a new index entry.
-        #
-        # @param tag [String] 4 byte entry tag (semantic data type)
-        # @param type [String] 4 byte entry data format
-        # @param offset [String] 4 byte pointer to data in the index store
-        # @param count [String] 4 byte number of data items held by the entry
-        def initialize(tag, type, offset, count)
-          @tag, @type, @offset, @count = tag, type, offset, count
-        end
-
-        attr_accessor :tag, :type, :offset, :count
-      end
-    end
-  end
-end

data/lib/rupert/rpm/signature/index.rb

@@ -1,32 +0,0 @@
-require 'rupert/rpm/signature/entry'
-require 'rupert/rpm/signature/store'
-
-module Rupert
-  class RPM
-    class Signature
-      class Index
-        # Initializes a new signature index, given the header's entries and the
-        # store containing actual data.
-        #
-        # @param entries [Hash] a map of
-        #                Rupert::RPM::Signature::Entry, indexed by tag
-        # @param store [Rupert::RPM::Signature::Store] store containing
-        #              data pointed by entries
-        def initialize(entries, store)
-          @entries = entries
-          @store = store
-        end
-
-        # Retrieves data pointed by given tag.
-        #
-        # @param tag [Fixnum] data type
-        # @return [Object] data associated to given tag, with variable format
-        #         depending on how it's stored
-        def get(tag)
-          entry = @entries[tag]
-          @store.fetch(entry)
-        end
-      end
-    end
-  end
-end

data/lib/rupert/rpm/signature/store.rb

@@ -1,35 +0,0 @@
-module Rupert
-class RPM
-  class Signature
-    # Package information is mostly contained in headers. Headers are composed
-    # of an index and a store.
-    # The (raw) store holds semantic RPM information in an undefined
-    # order and without any structure (i.e. by concatenating all pieces
-    # together). Addressing of resources in the store is handled by header
-    # entries, which define data format, position and size. Responsibility
-    # of the store is to take care of extracting these pieces given proper
-    # addressing information.
-    class Store
-      # Creates a new store by wrapping given chunck of raw data into a Store
-      # object.
-      #
-      # @param io [IO] raw binary data carved from RPM header. Must be an IO
-      #           containing only store's data (i.e. entry addresses are considered
-      #           relative to 0)
-      def initialize(io)
-        @io = io
-      end
-
-      # Fetches data pointed by given entry.
-      #
-      # @param entry [Rupert::RPM::Signature::Entry] entry containing address
-      #              and type of needed information
-      # @return [String] binary string containing asked data
-      def fetch(entry)
-        @io.seek(entry.offset, IO::SEEK_SET)
-        @io.read(entry.count)
-      end
-    end
-  end
-end
-end

data/test/unit/rpm/signature/index_test.rb

@@ -1,14 +0,0 @@
-require 'test_helper'
-
-describe Rupert::RPM::Signature::Index do
-  let(:entry)   { Rupert::RPM::Signature::Entry.new(1234, 7, 567, 890) }
-  let(:entries) { { entry.tag => entry } } 
-  let(:store)   { mock }
-  let(:index)   { Rupert::RPM::Signature::Index.new(entries, store) }
-
-  it "retrieves binary data marked with a specific tag from the store" do
-    store.expects(:fetch).once.with(entry)
-    
-    index.get(entry.tag)
-  end
-end

data/test/unit/rpm/signature/store_test.rb

@@ -1,12 +0,0 @@
-require 'test_helper'
-
-describe Rupert::RPM::Signature::Store do
-  let(:raw_io)  { io(ascii("\x00\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0a")) }
-  let(:entry)   { Rupert::RPM::Signature::Entry.new(nil, 7, 4, 5) }
-  let(:store)   { Rupert::RPM::Signature::Store.new(raw_io) }
-
-  it "fetches a raw chunck of data given the entry that points to it" do
-    data = store.fetch(entry)
-    data.must_equal ascii("\x04\x05\x06\x07\x08")
-  end
-end