tlv 0.0.3

data/lib/tlv/dgi.rb

@@ -0,0 +1,40 @@
+module TLV
+class DGI < TLV
+
+  def self.get_length(bytes)
+    len = bytes[0]  #CPS 2.2 Creation of ...
+    if len == 0xFF
+      len = bytes[1,2].unpack("n")[0] 
+    end
+    num = len > 0xfe ? 3 : 1
+    rest = bytes [num, bytes.length]
+    [len, rest]
+  end
+
+  def self.check_tag 
+    raise "incorrect tag length, dgi must be 2 : #{tag}" unless tag.length==2
+  end
+
+  def self.get_tag bytes
+    tag = bytes[0,2]
+    rest = bytes [2,bytes.length]
+    [tag, rest]
+  end
+
+  def get_len_bytes len
+    bytes = case len
+            when 0..0xfe : "" << len
+            when 0xff..65534 : "\xff"+[len].pack("n")
+            else
+                    raise "Don't be silly"
+            end
+  end
+
+  class << self
+    
+    def primitive?
+      false
+    end
+  end 
+end
+end # module

data/lib/tlv/field.rb

@@ -0,0 +1,24 @@
+module TLV
+class TLV
+class Field
+  attr_accessor :display_name, :name, :length
+  def initialize clazz, desc, name=nil, len=0
+    @length=len
+    unless name
+      name = desc.gsub(/\s/, "_")
+      name = name.gsub(/\W/, "")
+      name = name.downcase.to_sym
+    end
+    @name = name
+    @display_name = desc
+    define_accessor clazz
+  end
+  def parse tlv, bytes, length
+    raise "not implemented! use subclass"
+  end
+  def define_accessor clazz
+    #raise "Not primitive: #{clazz.to_s}, TAG=#{TLV.b2s clazz.tag}" unless clazz.primitive?
+  end
+end
+end
+end # module

data/lib/tlv/parse.rb

@@ -0,0 +1,87 @@
+module TLV
+class TLV
+  # return [tlv, rest], the parsed TLV and any leftover bytes.
+  def self.parse bytes
+    tlv, _ = self._parse bytes
+    return tlv
+  end
+
+  def self._parse bytes
+    return nil unless bytes && bytes.length>0
+    tag, _ = self.get_tag bytes
+    impl = lookup(tag)
+    tlv = impl.new 
+    rest = tlv.parse(bytes)
+    [tlv, rest]
+  end
+
+  def self.get_tag bytes
+    tag = (bytes[0,1])
+    if (tag[0] & 0x1f) == 0x1f # last 5 bits set, 2 byte tag
+      tag = bytes[0,2]
+      if (tag[1] & 0x80) == 0x80 # bit 8 set -> 3 byte tag
+        tag = bytes[0,3]
+      end
+    end
+    [tag, bytes[tag.length, bytes.length]]
+  end
+
+  def self.get_length bytes
+    len = bytes[0,1][0]
+    num_bytes=0
+
+    if (len & 0x80) == 0x80     # if MSB set 
+      num_bytes = len & 0x0F    # 4 LSB are num bytes total
+      raise "Don't be silly: #{b2s(bytes)}" if num_bytes > 4
+      len = bytes[1,num_bytes]
+      len = ("#{"\x00"*(4-num_bytes)}%s" % len).unpack("N")[0]
+    end
+    # this will return ALL the rest, not just `len` bytes of the rest. Does this make sense?
+    rest = bytes[1+num_bytes, bytes.length]
+    # TODO handle errors...
+    # warn if rest.length > length || rest.length < length ?
+    [len, rest]
+  end
+
+  def initialize bytes=nil
+    parse(bytes) if bytes
+  end
+
+  # returns the leftover bytes
+  def parse bytes
+    if tag
+      tag, rest = TLV.get_tag(bytes)
+      length, bytes = self.class.get_length(rest)
+    end
+    
+    if self.class.primitive?
+      bytes = parse_fields bytes, length
+    else
+      bytes = parse_tlv bytes, length
+    end
+
+    bytes
+
+  end
+
+  def parse_tlv bytes, length
+    b = bytes[0,length]
+    rest = bytes[length, bytes.length]
+
+    while b && b.length != 0
+      tlv, b = self.class._parse(b)
+      self.send("#{tlv.class.accessor_name}=", tlv)
+    end
+
+    rest
+  end
+  def parse_fields bytes, length
+    fields.each { |field|
+      bytes = field.parse(self, bytes, length)    
+    } if fields
+    bytes
+  end
+
+
+end
+end # module

data/lib/tlv/parser/dictionaries/asn.rb

@@ -0,0 +1,63 @@
+#universal numbers, source http://en.wikipedia.org/wiki/Basic_Encoding_Rules
+#
+TLV::UNIVERSAL = [
+['EOC (End-of-Content)',"P",0x00],
+['BOOLEAN',"P",0x01],
+['INTEGER',"P",0x02],
+['BIT STRING',"P/C",0x03],
+['OCTET STRING',"P/C",0x04],
+['NULL',"P",0x05],
+['OBJECT IDENTIFIER',"P",0x06],
+['Object Descriptor',"P",0x07],
+['EXTERNAL',"C",0x08],
+['REAL (float)',"P",0x09],
+['ENUMERATED',"P",0x0A],
+['EMBEDDED PDV',"C",0x0B],
+['UTF8String',"P/C",0x0C],
+['RELATIVE-OID',"P",0x0D],
+['SEQUENCE and SEQUENCE OF',"C",0x10],
+['SET and SET OF',"C",0x11],
+['NumericString',"P/C",0x12],
+['PrintableString',"P/C",0x13],
+['T61String',"P/C",0x14],
+['VideotexString',"P/C",0x15],
+['IA5String',"P/C",0x16],
+['UTCTime',"P/C",0x17],
+['GeneralizedTime',"P/C",0x18],
+['GraphicString',"P/C",0x19],
+['VisibleString',"P/C",0x1A],
+['GeneralString',"P/C",0x1B],
+['UniversalString',"P/C",0x1C],
+['CHARACTER STRING',"P/C",0x1D],
+['BMPString',"P/C",0x1E],
+]
+
+def make_dict
+  def add_primitive e,d
+    tag = ("" <<  e[2])
+    d[tag] = e[0]
+  end
+  def add_const e,d
+    tag = "" << (e[2] | 0x20)
+    d[tag] = e[0]
+  end
+  dict = {}
+  TLV::UNIVERSAL.each {|entry|
+    case entry[1]
+    when "P"
+      add_primitive entry, dict
+    when "C"
+      add_const entry, dict
+    when "P/C"
+      add_primitive entry, dict
+      add_const entry, dict
+    end
+  }
+  TLV::DICTIONARIES["ASN"] = dict
+end
+make_dict
+
+#TLV::DICTIONARIES["ASN"].each_pair{|key,value|
+#  puts "#{TLV.b2s(key)} #{value}"
+#}
+

data/lib/tlv/parser/dictionaries/dictionaries.rb

@@ -0,0 +1,2 @@
+require 'tlv/parser/dictionaries/emv_tags'
+require 'tlv/parser/dictionaries/asn'

data/lib/tlv/parser/dictionaries/emv_tags.rb

@@ -0,0 +1,130 @@
+TLV::DICTIONARIES["EMV"] = {
+  "\x42" => "Issuer Identification Number (IIN)",
+  "\x4F" => "Application Identifier (AID) - card",
+  "\x4F" => "AID",
+  "\x50" => "Application Label",
+  "\x57" => "Track 2 Equivalent Data",
+  "\x5A" => "Application Primary Account Number (PAN)",
+  "\x5A" => "PAN",
+  "\x5F\x20" => "Cardholder Name",
+  "\x5F\x24" => "Application Expiration Date",
+  "\x5F\x25" => "Application Effective Date",
+  "\x5F\x28" => "Issuer Country Code",
+  "\x5F\x2A" => "Transaction Currency Code",
+  "\x5F\x2D" => "Language Preference",
+  "\x5F\x30" => "Service Code",
+  "\x5F\x34" => "Application Primary Account Number (PAN) Sequence Number",
+  "\x5F\x36" => "Transaction Currency Exponent",
+  "\x5F\x50" => "Issuer URL",
+  "\x5F\x53" => "International Bank Account Number (IBAN)",
+  "\x5F\x54" => "Bank Identifier Code (BIC)",
+  "\x5F\x55" => "Issuer Country Code (alpha2 format)",
+  "\x5F\x56" => "Issuer Country Code (alpha3 format)",
+  "\x61" => "Application Template",
+  "\x6F" => "File Control Information (FCI) Template",
+  "\x70" => "READ RECORD Response Message Template",
+  "\x71" => "Issuer Script Template 1",
+  "\x72" => "Issuer Script Template 2",
+  "\x73" => "Directory Discretionary Template",
+  "\x77" => "Response Message Template Format 2",
+  "\x80" => "Response Message Template Format 1",
+  "\x81" => "Amount, Authorised (Binary)",
+  "\x82" => "Application Interchange Profile",
+  "\x83" => "Command Template",
+  "\x84" => "Dedicated File (DF) Name",
+  "\x86" => "Issuer Script Command",
+  "\x87" => "Application Priority Indicator",
+  "\x88" => "Short File Identifier (SFI)",
+  "\x88" => "SFI",
+  "\x89" => "Authorisation Code",
+  "\x8A" => "Authorisation Response Code",
+  "\x8C" => "Card Risk Management Data Object List 1 (CDOL1)",
+  "\x8C" => "CDOL1",
+  "\x8D" => "Card Risk Management Data Object List 2 (CDOL2)",
+  "\x8D" => "CDOL2",
+  "\x8E" => "Cardholder Verification Method (CVM) List",
+  "\x8E" => "CVM List",
+  "\x8F" => "Certification Authority Public Key Index",
+  "\x90" => "Issuer Public Key Certificate",
+  "\x91" => "Issuer Authentication Data",
+  "\x92" => "Issuer Public Key Remainder",
+  "\x93" => "Signed Static Application Data",
+  "\x94" => "Application File Locator (AFL)",
+  "\x94" => "Application File Locator",
+  "\x95" => "Terminal Verification Results",
+  "\x97" => "Transaction Certificate Data Object List (TDOL)",
+  "\x98" => "Transaction Certificate (TC) Hash Value",
+  "\x99" => "Transaction Personal Identification Number (PIN) Data",
+  "\x9A" => "Transaction Date",
+  "\x9B" => "Transaction Status Information",
+  "\x9C" => "Transaction Type",
+  "\x9D" => "Directory Definition File (DDF) Name",
+  "\x9F\x01" => "Acquirer Identifier",
+  "\x9F\x02" => "Amount, Authorised (Numeric)",
+  "\x9F\x03" => "Amount, Other (Numeric)",
+  "\x9F\x04" => "Amount, Other (Binary)",
+  "\x9F\x05" => "Application Discretionary Data",
+  "\x9F\x06" => "Application Identifier (AID) - terminal",
+  "\x9F\x07" => "Application Usage Control",
+  "\x9F\x08" => "Application Version Number",
+  "\x9F\x09" => "Application Version Number",
+  "\x9F\x0B" => "Cardholder Name Extended",
+  "\x9F\x0D" => "Issuer Action Code - Default",
+  "\x9F\x0E" => "Issuer Action Code - Denial",
+  "\x9F\x0F" => "Issuer Action Code - Online",
+  "\x9F\x10" => "Issuer Application Data",
+  "\x9F\x11" => "Issuer Code Table Index",
+  "\x9F\x12" => "Application Preferred Name",
+  "\x9F\x13" => "Last Online Application Transaction Counter (ATC) Register",
+  "\x9F\x14" => "Lower Consecutive Offline Limit",
+  "\x9F\x15" => "Merchant Category Code",
+  "\x9F\x16" => "Merchant Identifier",
+  "\x9F\x17" => "Personal Identification Number (PIN) Try Counter",
+  "\x9F\x18" => "Issuer Script Identifier",
+  "\x9F\x1A" => "Terminal Country Code",
+  "\x9F\x1B" => "Terminal Floor Limit",
+  "\x9F\x1C" => "Terminal Identification",
+  "\x9F\x1D" => "Terminal Risk Management Data",
+  "\x9F\x1E" => "Interface Device (IFD) Serial Number",
+  "\x9F\x1F" => "Track 1 Discretionary Data",
+  "\x9F\x20" => "Track 2 Discretionary Data",
+  "\x9F\x21" => "Transaction Time",
+  "\x9F\x23" => "Upper Consecutive Offline Limit",
+  "\x9F\x26" => "Application Cryptogram",
+  "\x9F\x27" => "Cryptogram Information Data",
+  "\x9F\x2D" => "ICC PIN Encipherment Public Key Certificate",
+  "\x9F\x2E" => "ICC PIN Encipherment Public Key Exponent",
+  "\x9F\x2F" => "ICC PIN Encipherment Public Key Remainder",
+  "\x9F\x32" => "Issuer Public Key Exponent",
+  "\x9F\x33" => "Terminal Capabilities",
+  "\x9F\x34" => "Cardholder Verification Method (CVM) Results",
+  "\x9F\x35" => "Terminal Type",
+  "\x9F\x36" => "Application Transaction Counter (ATC)",
+  "\x9F\x37" => "Unpredictable Number",
+  "\x9F\x38" => "Processing Options Data Object List (PDOL)",
+  "\x9F\x38" => "PDOL",
+  "\x9F\x39" => "Point-of-Service (POS) Entry Mode",
+  "\x9F\x3A" => "Amount, Reference Currency",
+  "\x9F\x3B" => "Application Reference Currency",
+  "\x9F\x3C" => "Transaction Reference Currency Code",
+  "\x9F\x3D" => "Transaction Reference Currency Exponent",
+  "\x9F\x40" => "Additional Terminal Capabilities",
+  "\x9F\x41" => "Transaction Sequence Counter",
+  "\x9F\x42" => "Application Currency Code",
+  "\x9F\x43" => "Application Reference Currency Exponent",
+  "\x9F\x44" => "Application Currency Exponent",
+  "\x9F\x45" => "Data Authentication Code",
+  "\x9F\x46" => "ICC Public Key Certificate",
+  "\x9F\x47" => "ICC Public Key Exponent",
+  "\x9F\x48" => "ICC Public Key Remainder",
+  "\x9F\x49" => "Dynamic Data Authentication Data Object List (DDOL)",
+  "\x9F\x49" => "DDOL",
+  "\x9F\x4A" => "Static Data Authentication Tag List",
+  "\x9F\x4B" => "Signed Dynamic Application Data",
+  "\x9F\x4C" => "ICC Dynamic Number",
+  "\x9F\x4D" => "Log Entry",
+  "\x9F\x4E" => "Merchant Name and Location",
+  "\x9F\x4F" => "Log Format",
+  "\xA5" => "File Control Information (FCI) Proprietary Template",
+  "\xBF\x0C" => "File Control Information (FCI) Issuer Discretionary Data",
+}

data/lib/tlv/parser/parser.rb

@@ -0,0 +1,167 @@
+# Simple lib to deconstruct tlv data
+# TLV.parse str
+# TLV.parse_hex str
+require 'hexy'
+
+module TLV
+  DICTIONARIES = {}
+  # Attempt to parse a (series) or BER encoded
+  # datastructures. May be be passed a 
+  #   
+  #   "\x00"=> "Tag Name"
+  #
+  # encoded dictionary to provide names for tags.
+  # Some dictionaries are predefined in TLV::DICTIONARIES
+  #
+  # Parameters:
+  # +bytes+ : a string of raw bytes to decode
+  # +dictionary+ : a tag=>name dictionary for tagname lookup
+  #
+  # Returns:
+  # a string respresenation of the datastructure
+  def self.parse bytes, dictionary={}
+    _dump(_parse(bytes), dictionary)
+  end
+
+  #
+  # Attempt to decode a (series) of BER encoded
+  # datastructures (see parse)
+  #
+  # The data passed to this method is expected to 
+  # be hex formated instead of in binary form.
+  #
+  def self.parse_hex hex_str, dictionary={}
+    self.parse s2b(hex_str), dictionary
+  end
+
+  #
+  # Attempt to decode a DGI encoded datastructure.
+  # This is used in EMV (CPS).
+  # see parse
+  #
+  def self.parse_dgi bytes, dictionary={}
+    _dump(_parse_dgi(bytes), dictionary) 
+  end
+  
+  #
+  # Attempt to decode a DGI encoded datastructure.
+  # This is used in EMV (CPS).
+  # see parse_hex
+  #
+  def self.parse_dgi_hex hex_str, dictionary={}
+    self.parse_dgi s2b(hex_str), dictionary
+  end
+  # heuristics to determine whether a string of bytes
+  # is worth printing. If more than 90% of bytes are
+  # printable, will return true.
+  def self.printable? bytes
+    count = 0
+    count_printable = 0
+    bytes.each_byte {|b|
+      count += 1
+      count_printable += 1 if ((0x20..0x7e).include?(b) || (0xA0..0xff).include?(b)) 
+    }
+    return (count_printable.to_f/count) > 0.90
+  end
+
+  #--
+  # Stop RDOC here.
+  def self._parse bytes #:nodoc: 
+    tlvs = []
+    begin
+      tlv, rest = _parse_tlv bytes
+      tlvs << tlv
+      bytes = rest
+    end while rest && rest.length != 0
+    tlvs
+  end
+
+  def self._parse_dgi bytes #:nodoc: 
+    dgis = []
+    begin
+      dgi = TLV_Object.new
+      tag, rest    = DGI.get_tag bytes
+      dgi.tag      = tag
+      len, rest    = DGI.get_length rest
+      dgi.length   = len
+      if tag == "\x80\x00" || tag == "\x90\x00"
+        # no children
+        dgi.value = rest[0,len]
+      else
+        dgi.children = _parse rest[0,len]
+      end
+      dgis << dgi
+      bytes = rest[len, rest.length]
+    end while bytes && bytes.length != 0
+    dgis
+  end
+  
+
+  def self._parse_tlv bytes #:nodoc: 
+    tlv = TLV_Object.new
+    tag, rest = TLV.get_tag bytes
+    tlv.tag = tag
+    len, rest = TLV.get_length rest
+    tlv.length = len
+    if (tag[0] & 0x20) != 0x00 # constructed object
+      tlv.children = _parse rest[0,len]
+    else
+      tlv.value = rest[0,len]
+    end
+    [tlv, rest[len, rest.length]]
+  end
+
+  def self._dump (tlvs, dictionary, indent = "") #:nodoc: 
+    dump = ""
+    tlvs.each {|tlv|
+      dump += "%s%-6s : %d" % [indent, "0x"+b2s(tlv.tag), tlv.length]
+      if tlv.children
+        dump += " ["+dictionary[tlv.tag]+"]" if (dictionary[tlv.tag])
+        dump += "\n"
+        tlv.children.each {|child|
+          dump += _dump([child], dictionary, indent+"  ")
+        }
+      else
+        if (tlv.value.length < 17)
+          dump += " : " + b2s(tlv.value) 
+          dump += "  (#{tlv.value})" if printable?(tlv.value)
+          dump += " ["+dictionary[tlv.tag]+"]" if (dictionary[tlv.tag])
+        else
+          dump += " ["+dictionary[tlv.tag]+"]" if (dictionary[tlv.tag])
+          dump +="\n"
+          dump += Hexy.dump(tlv.value, :indent=>indent.length+2)
+        end
+
+        dump += "\n"
+      end
+    }
+    #puts ">>>>"
+    #puts dump
+    #puts "<<<<"
+    dump
+  end
+  class TLV_Object
+    attr_accessor :tag, :length, :value, :children
+  end
+end
+
+if $0 == __FILE__
+  require "tlv"
+#  puts TLV.parse_hex("9f7103313233")  
+#  puts
+#  puts TLV.parse_hex("32084102010243023456")  
+#  puts
+#  puts TLV.parse_hex("320841020102430234")
+#  puts
+#  dict = {"\x32" => "Test Tag", "\x41" => "Other Tag"}
+#  puts TLV.parse_hex("32084102010243023456", dict)
+#  puts
+#  puts TLV.parse_hex("320841020102430234569f7103313233", dict)
+#  puts
+  dict = {"\x57" => "Track 2 Equivalent Data",
+          "\x70" => "READ RECORD Response Message Template"}
+  puts TLV.parse_dgi_hex("010142704057134451973022158124D12102011089573110000F5F201A4D55535445524D414E4E2F4D41582020202020202020202020209F1F0B0102030405060708090A0B")
+  puts
+  puts TLV.parse_dgi_hex("010142704057134451973022158124D12102011089573110000F5F201A4D55535445524D414E4E2F4D41582020202020202020202020209F1F0B0102030405060708090A0B02018670818390818047D56F644D05FF41180926D965765BBC1894E6F973FA6DD56FC69313E82E9480F3405D7A4056B3AB5F31293D22F55A460D540E954BCF74E3D056DA839E756D1C6AC4BAD76D2747E158288BDE28CEEB321C930ED2F40ED35884304DD3D69E87BBC81FBEE22ACD2F0851A5DCA6DAAC794E633A70072AF5B93103C115B225118B77 ", dict)
+end
+#++