axlsx 1.1.7 → 1.1.8

data/lib/axlsx/util/cfb.rb~

@@ -1,201 +0,0 @@
-module Axlsx
-
-  # The Cfb class is a MS-OFF-CRYPTOGRAPHY specific OLE (MS-CBF) writer implementation. No attempt is made to re-invent the wheel for read/write of compound binary files.
-  class Cbf
-
-    # the serialization for the CBF FAT
-    FAT_PACKING  = "s128"
-
-    # the serialization for the MS-OFF-CRYPTO version stream
-    VERSION_PACKING = 'l s30 l3'
-
-    # The serialization for the MS-OFF-CRYPTO dataspace map stream
-    DATA_SPACE_MAP_PACKING = 'l6 s16 l s25'
-
-    # The serialization for the MS-OFF-CRYPTO strong encrytion data space stream
-    STRONG_ENCRYPTION_DATA_SPACE_PACKING = 'l3 s25'
-
-    # The serialization for the MS-OFF-CRYPTO primary stream
-    PRIMARY_PACKING = 'l3 s38 l s39 l3 x12 l x2'
-
-    # The cutoff size that determines if a stream should be in the mini-fat or the fat
-    MINI_CUTOFF = 4096
-
-    # Creates a new Cbf object based on a package.
-    def initialize(ms_off_crypto)
-      @file_name = ms_off_crypto.file_name  
-      @storages = []
-      @encryption_info = ms_off_crypto.encryption_info
-      @encrypted_package = ms_off_crypto.encrypted_package
-      @storages << Storage.new('R', :type=>Storage::TYPES[:root], :color=>Storage::COLORS[:red], :child=>1, :modified=>129685612742510730)
-      @storages.last.name_size = 2
-      @storages << Storage.new('EncryptionInfo', :data=>@encryption_info, :left=>3, :size => @encryption_info.size) # example shows right child. do we need the summary info????
-      @storages << Storage.new('EncryptedPackage', :data=>@encrypted_package, :color=>Storage::COLORS[:red], :size=>@encrypted_package.size)
-      @storages << Storage.new([6].pack("c")+"DataSpaces", :child=>5, :modified =>129685612740945580, :created=>129685612740819979)
-      @storages << version
-      @storages << data_space_map
-      @storages << Storage.new('DataSpaceInfo', :right=>8, :child=>7, :created=>129685612740828880,:modified=>129685612740831800)
-      @storages << strong_encryption_data_space
-      @storages << Storage.new('TransformInfo', :color => Storage::COLORS[:red],  :child=>9, :created=>129685612740834130, :modified=>129685612740943959)
-      @storages << Storage.new('StrongEncryptionTransform', :child=>10, :created=>129685612740834169, :modified=>129685612740942280)
-      @storages << primary
-      mini_fat_stream
-      mini_fat
-      fat
-      header
-    end
-
-    def version
-      @version ||= create_version
-    end
-
-    def data_space_map
-      @data_space_map ||= create_data_space_map
-    end
-
-    def strong_encryption_data_space
-      @strong_encryption_data_space ||= create_strong_encryption_data_space
-    end
-
-    def primary
-      @primary ||= create_primary
-    end
-    
-    
-    def create_primary
-      v_stream = [88,1,76,"{FF9A3F03-56EF-4613-BDD5-5A41C1D07246}".bytes.to_a].flatten
-      v_stream.concat [78, "Microsoft.Container.EncryptionTransform".bytes.to_a,1,1,1,4].flatten
-      v_stream = v_stream.pack PRIMARY_PACKING
-      Storage.new([6].pack("c")+"Primary", :data=>v_stream, :size=>v_stream.size)
-    end
-
-    def create_strong_encryption_data_space
-      v_stream = [8,1,50,"StrongEncryptionTransform".bytes.to_a].flatten.pack STRONG_ENCRYPTION_DATA_SPACE_PACKING
-      Storage.new("StrongEncryptionDataSpace", :data=>v_stream, :size => v_stream.size)
-    end
-
-    # Create the version storage
-    def create_version
-      v_stream= [60, "Microsoft.Container.DataSpaces".bytes.to_a, 1, 1, 1].flatten!.pack VERSION_PACKING
-      Storage.new('Version', :data=>v_stream, :size=>v_stream.size)
-    end
-
-    def create_data_space_map
-      v_stream = [8,1,104, 1,0, 32, "EncryptedPackage".bytes.to_a, 50, "StrongEncryptionDataSpace".bytes.to_a].flatten!.pack DATA_SPACE_MAP_PACKING      
-      Storage.new('DataSpaceMap', :data=>v_stream, :left => 4, :right => 6, :size=>v_stream.size)
-    end
-
-    def allocate_stream(table, stream, size)
-      stream.sector = table.size if stream.respond_to?(:sector)
-      ((stream.size / size.to_f).ceil).times { table << table.size }
-      table[table.size-1] = -2
-    end
-
-    def fat_stream 
-      @fat_stream ||= create_fat_stream
-    end
-    def create_fat_stream
-      mfs = []
-      @storages.select{ |s| s.type == Storage::TYPES[:stream] && s.size >= MINI_CUTOFF}.each_with_index do |stream, index|
-        mfs.concat stream.data
-        mfs.concat Array.new(512 - (mfs.size % 512), 0) if mfs.size % 512        
-      end
-      mfs.pack 'c*'
-    end
-
-    def mini_fat_stream
-      @mini_fat_stream ||= create_mini_fat_stream
-    end
-    
-    def create_mini_fat_stream
-      mfs = []
-      @storages.select{ |s| s.type == Storage::TYPES[:stream] && s.size < MINI_CUTOFF}.each_with_index do |stream, index|
-        mfs.concat stream.data
-        mfs.concat Array.new(64 - (mfs.size % 64), 0) if mfs.size % 64        
-      end
-      @storages[0].size = mfs.size
-      mfs.concat(Array.new(512 - (mfs.size % 512), 0))
-      mfs.pack 'c*'
-    end
-
-    def mini_fat
-      @mini_fat ||= create_mini_fat
-    end
-
-    def create_mini_fat
-      v_mf = []
-      @storages.select{ |s| s.type == Storage::TYPES[:stream] && s.size < MINI_CUTOFF}.each do |stream|
-        allocate_stream(v_mf, stream, 64)
-      end
-      v_mf.concat Array.new(128 - v_mf.size, -1)
-      v_mf.pack 'l*'
-    end
-
-    def fat
-      @fat ||= create_fat
-    end
-
-    def create_fat
-      v_fat = [-3]
-      # storages four per sector, allocation forces directories to start at sector ID 0
-      allocate_stream(v_fat, @storages, 4)
-      # fat entry for minifat
-      allocate_stream(v_fat, 0, 512)
-      # fat entry for minifat stream
-      @storages[0].sector = v_fat.size
-      allocate_stream(v_fat, mini_fat_stream, 512)
-      # fat entries for encrypted package storage
-      # what to do about DIFAT for larger packages...
-      if @encrypted_package.size > (109 - v_fat.size) * 512
-        raise ArgumentError, "Your package is too big!"
-      end
-
-      if @encrypted_package.size >= MINI_CUTOFF
-        allocate_stream(v_fat, @encrypted_package, 512)
-      end
-
-      v_fat.concat Array.new(128 - v_fat.size, -1) if v_fat.size < 128 #pack in unused sectors
-      v_fat.pack 'l*'
-    end
-
-    def header
-      @header ||= create_header
-    end
-
-    # The serialization for CBF header
-    HEADER_PACKING = "q x16 l s3 x10 l l x4 l*"
-
-    def create_header
-      header = []
-      header << -2226271756974174256 # identifier pack as q
-      header << 196670 # version pack as L
-      header << 65534 # byte order pack as s
-      header << 9 # sector shift
-      header << 6 # mini-sector shift
-      header << (fat.size/512.0).ceil # this is the number of FAT sectors in the file at index 6 pack as L
-      header << header.last # this is the first directory sector, index of 7 pack as L
-      header << MINI_CUTOFF # minfat cutoff pack as L
-      # MiniFat starts after directories
-      header << (fat.size/512.0).ceil + (@storages.size/4.0).ceil # this is the sector id for the first minifat index 10 pack as L
-      header << (mini_fat.size/512.0).ceil # minifat sector count index 11 pack as L
-      header << -2 # the first DIFAT - set to end of chain until we exceed a single FAT pack as L
-      header << 0 # number of DIFAT sectors, unless we go beyond 109 FAT sectors this will always be 0 pack as L
-      header << 0 # first FAT sector defined in the DIFAT pack as L
-      header.concat Array.new(108, -1) # Difat sectors pack as L108
-    end
-
-    def save
-
-      ole = File.open(@file_name, 'w')
-      ole << header.pack(HEADER_PACKING)
-      ole << fat
-      @storages.each { |s| ole << s.to_s }
-      ole << Array.new((512-(ole.pos % 512)), 0).pack('c*')
-      ole << mini_fat
-      ole << mini_fat_stream
-      ole << fat_stream
-      ole.close
-    end
- 
-  end
-end

data/lib/axlsx/util/ms_off_crypto.rb

@@ -1,189 +0,0 @@
-# encoding: UTF-8
-require 'digest'
-require 'base64'
-require 'openssl'
-
-module Axlsx
-
-  # The MsOffCrypto class implements ECMA-367 encryption based on the MS-OFF-CRYPTO specification
-  class MsOffCrypto
-
-    # Creates a new MsOffCrypto Object
-    # @param [String] file_name the location of the file you want to encrypt
-    # @param [String] pwd the password to use when encrypting the file
-    def initialize(file_name, pwd)
-      self.password = pwd
-      self.file_name = file_name
-    end
-
-    # Generates a new CBF file based on this instance of ms-off-crypto and overwrites the unencrypted file.
-    def save
-      cfb = Cbf.new(self)
-      cfb.save
-    end
-
-    # returns the raw password used in encryption
-    # @return [String]
-    attr_reader :password
-
-    # sets the password to be used for encryption
-    # @param [String] v the password, @default 'password'
-    # @return [String]
-    def password=(v)
-      @password = v || 'password'
-    end
-
-    # retruns the file name of the archive to be encrypted
-    # @return [String]
-    attr_reader :file_name
-
-    # sets the filename
-    # @return [String]
-    def file_name=(v)
-      #TODO verfify that the file specified exists and is an unencrypted xlsx archive
-      @file_name = v
-    end
-
-
-    # encrypts and returns the package specified by the file name 
-    # @return [String]
-    def encrypted_package
-      @encrypted_package ||= encrypt_package(file_name)
-    end
-
-    # returns the encryption info for this instance of ms-off-crypto
-    # @return [String]
-    def encryption_info 
-      @encryption_info ||= create_encryption_info
-    end
-
-    # returns a random salt
-    # @return [String]
-    def salt
-      @salt ||= Digest::SHA1.digest(rand(16**16).to_s)
-    end
-
-    # returns a random verifier
-    # @return [String]
-    def verifier 
-      @verifier ||= rand(16**16).to_s
-    end
-
-    # returns the verifier encrytped
-    # @return [String]
-    def encrypted_verifier
-      @encrypted_verifier ||= encrypt(verifier)
-    end
-
-    # returns the verifier hash encrypted
-    # @return [String]
-    def encrypted_verifier_hash
-      @encrypted_verifier_hash ||= encrypt(verifier_hash)
-    end
-
-    # returns a verifier hash
-    # @return [String]
-    def verifier_hash
-      @verifier_hash ||= create_verifier_hash
-    end
-
-    # returns an encryption key
-    # @return [String]
-    def key 
-      @key ||= create_key
-    end
-    
-    # size of unencrypted package? concated with encrypted package
-    def encrypt_package(file_name)      
-      package = File.open(file_name, 'r')
-      crypt_pack = encrypt(package.read)      
-      [crypt_pack.size].pack('q') + crypt_pack
-    end
-
-    # Generates an encryption info structure
-    # @return [String]
-    def create_encryption_info
-      header = [3, 0, 2, 0] # version
-      # Header flags copy
-      header.concat [0x24, 0, 0, 0] #flags -- VERY UNSURE ABOUT THIS STILL
-      # header.concat [0, 0, 0, 0] #unused
-      header.concat [0xA4, 0, 0, 0] #length
-      # Header
-      header.concat  [0x24, 0, 0, 0] #flags again
-      # header.concat [0, 0, 0, 0] #unused again,
-      header.concat [0x0E, 0x66, 0, 0] #alg id
-      header.concat [0x04, 0x80, 0, 0] #alg hash id
-      header.concat [key.size, 0, 0, 0] #key size
-      header.concat [0x18, 0, 0, 0] #provider type
-      # header.concat [0, 0, 0, 0] #reserved 1
-      # header.concat [0, 0, 0, 0] #reserved 2
-      header.concat [0xA0, 0xC7, 0xDC, 0x2, 0, 0, 0, 0]
-      header.concat "Microsoft Enhanced RSA and AES Cryptographic Provider (Prototype)".bytes.to_a.pack('s*').bytes.to_a
-      header.concat [0, 0] #null terminator
-
-      #Salt Size
-      header.concat [salt.bytes.to_a.size].pack('l').bytes.to_a
-      #Salt
-      header.concat salt.bytes.to_a.pack('c*').bytes.to_a
-      # encryption verifier
-      header.concat encrypted_verifier.bytes.to_a.pack('c*').bytes.to_a
-
-      # verifier hash size -- MUST BE 32 bytes
-      header.concat [verifier_hash.bytes.to_a.size].pack('l').bytes.to_a
-
-      #encryption verifier hash
-      header.concat encrypted_verifier_hash.bytes.to_a.pack('c*').bytes.to_a
-
-      header.flatten!
-      header.pack('c*')
-    end
-
-    # 2.3.3
-    def create_verifier_hash
-      vh = Digest::SHA1.digest(verifier)
-      vh << Array.new(32 - vh.size, 0).join('')
-    end
-
-    # 2.3.4.7 ECMA-376 Document Encryption Key Generation (Standard Encryption)
-    def create_key
-      sha = Digest::SHA1.new() << (salt + @password)
-      (0..49999).each { |i| sha.update(i.to_s+sha.to_s) }
-      key = sha.update(sha.to_s+'0').digest
-      a = key.bytes.each_with_index.map { |item, i|  0x36 ^ item }
-      x1 = Digest::SHA1.digest((a.concat Array.new(64 - key.size, 0x36)).to_s)
-      a = key.bytes.each_with_index.map { |item, i| 0x5C ^ item }
-      x2 = Digest::SHA1.digest( (a.concat Array.new(64 - key.size, 0x5C) ).to_s)
-      x3 = x1 + x2
-      x3.bytes.to_a[(0..31)].pack('c*')
-    end
-
-    # ensures that the a hashed decryption of the encryption verifier matches the decrypted verifier hash.
-    # @return [Boolean]
-    def verify_password
-      v = Digest::SHA1.digest decrypt(@encrypted_verifier)
-      vh = decrypt(@encrypted_verifier_hash)
-      vh[0..15] == v[0..15]
-    end
-
-    # encrypts the data proved 
-    # @param [String] data
-    # @return [String] the encrypted data
-    def encrypt(data)
-      aes = OpenSSL::Cipher.new("AES-128-ECB")     
-      aes.encrypt
-      aes.key = key
-      aes.update(data) << aes.final
-    end
-
-    # dencrypts the data proved 
-    # @param [String] data
-    # @return [String] the dencrypted data
-    def decrypt(data)
-      aes = OpenSSL::Cipher.new("AES-128-ECB")     
-      aes.decrypt
-      aes.key = key
-      aes.update(data) << aes.final
-    end
-
-  end
-end

data/lib/axlsx/util/ms_off_crypto.rb~

@@ -1,3 +0,0 @@
-module Axlsx
-  class MsOffcrypto
-end

data/lib/axlsx/util/parser.rb~

@@ -1,6 +0,0 @@
-module Axlsx
-# THe Parser class unzips an xlsx spread sheet and populates a new axlsx package from it.
-  class Parser
-
-  end
-end

data/lib/axlsx/workbook/shared_strings_table.rb~

@@ -1,69 +0,0 @@
-# encoding: UTF--8
-module Axlsx
-
-  # The Shared String Table class is responsible for managing and serializing common strings in a workbook.
-  # While the ECMA-376 spec allows for both inline and shared strings it seems that at least some applications like Numbers (Mac)
-  # and Google Docs require that the shared string table is populated in order to interoperate properly. 
-  # As a developer, you should never need to directly work against this class. Simply set 'use_shared_strings'
-  # on the package or workbook to generate a package that uses the shared strings table instead of inline strings.
-  # @note Serialization performance is affected by using this serialization method so if you do not need interoperability
-  # it is recomended that you use the default inline string method of serialization.
-  class SharedStringsTable
-
-    # The total number of strings in the workbook including duplicates
-    # Empty cells are treated as blank strings
-    # @return [Integer]
-    attr_reader :count
-
-    # The total number of unique strings in the workbook. 
-    # @return [Integer]
-    def unique_count
-      @unique_cells.size
-    end
-
-    # An array of unique cells. Multiple attributes of the cell are used in comparison
-    # each of these unique cells is parsed into the shared string table.     
-    # @see Cell#sharable
-    attr_reader :unique_cells
-
-    # Creates a new Shared Strings Table agains an array of cells
-    # @param [Array] cells This is an array of all of the cells in the workbook
-    def initialize(cells)
-      cells = cells.reject { |c| c.type != :string }
-      @count = cells.size
-      @unique_cells = []
-      resolve cells
-    end
-
-    # Interate over all of the cells in the array. 
-    # if our unique cells array does not contain a sharable cell, 
-    # add the cell to our unique cells array and set the ssti attribute on the index of this cell in the shared strings table
-    # if a sharable cell already exists in our unique_cells array, set the ssti attribute of the cell and move on.
-    # @return [Array] unique cells
-    def resolve(cells)
-      cells.each do |cell|
-        index = @unique_cells.index { |item| item.sharable(cell) }
-        if index == nil
-          cell.ssti = @unique_cells.size
-          @unique_cells << cell
-        else
-          cell.ssti = index
-        end
-      end
-    end
-
-    # Generate the xml document for the Shared Strings Table
-    # @return [String]
-    def to_xml
-      builder = Nokogiri::XML::Builder.new(:encoding => ENCODING) do |xml|
-        xml.sst(:xmlns => Axlsx::XML_NS, :count => count, :uniqueCount => unique_count) {
-          @unique_cells.each do |cell|
-            xml.si { xml.t cell.value.to_s }
-          end
-        }
-      end
-      builder.to_xml(:save_with => 0)
-    end
-  end
-
-end