EMV/PBOC解析(三) TLV格式解析(C#)

1.什么是TLV格式?

TLV即Tag-Length-Value，常在IC卡与POS终端设备中通过这样的一个应用通信协议进行数据交换。 金融系统中的TLV是BER-TLV编码的一个特例编码规范，而BER-TLV是ISO定义中的规范。在TLV的定义中，可以知道它包括三个域，分别为：标签域（Tag），长度域（Length），内容域（Value）。这里的长度域的值实际上就是内容域的长度。 其实，在BER编码的方式有两种情况，一种是确定长度的方式，一种是不确定长度的方式，而金融TLV选择了确定长度的方式，这样在设备之间的数据传输量上就可以减少。

2.Tag域

3.Length域

当b8为0时，该字节的b7-b1作为value域的长度；当b8为1时，b7-b1作为后续字节的长度。例：10000011，代表后续还有3个字节作为value域的长度（本字节不算，本字节变为作为一个Length的索引）。3个字节代表value的长度，意味着什么呢，意味着内容的长度当需要很大的时候，字节的位数就会跟着越高，3个字节就代表最大可以有256*256*256的长度。

4.Value域

分成两种情况考虑，就是前面说到的Tag分成两个数据元结构，一种是简单数据元结构，一种是复合数据元架构：

先来看看简单数据元结构：

复合数据元结构：

5.TLV格式数据实例

数据： 5F2D027A68

Tag域

5F → 01011111 → 5F 2D → 00101101 → 5F2D

Length域

02 → 00000010 → 02(2字节)

Value域

7A68

6.算法实现 C#

首先根据定义创建一个实体类

 /// <summary>
     /// TLV格式报文实体类
     /// </summary>
     public class TLVEntity
     {
         /// <summary>
         /// 标记
         /// </summary>
         public byte[] Tag { get; set; }

         /// <summary>
         /// 数据长度
         /// </summary>
         public byte[] Length { get; set; }

         /// <summary>
         /// 数据
         /// </summary>
         public byte[] Value { get; set; }

         /// <summary>
         /// 标记占用字节数
         /// </summary>
         public int TagSize { get { return this.Tag.Length; } }

         /// <summary>
         /// 数据长度占用字节数
         /// </summary>
         public int LengthSize { get { return this.Length.Length; } }

         /// <summary>
         /// 子嵌套TLV实体列表
         /// </summary>
         public List<TLVEntity> SubTLVEntity { get; set; }
     }

下面是tlv格式报文打包解析

 　　 /// <summary>
     /// TLV格式报文打包解析
     /// </summary>
     public class TLVPackage
     {
         #region TLV 打包

         /// <summary>
         /// TLV报文打包
         /// </summary>
         /// <param name="buffer">字节数据</param>
         /// <returns></returns>
         public static List<TLVEntity> Construct(byte[] buffer)
         {
             List<TLVEntity> resultList = new List<TLVEntity>();
             int currentIndex = ;
             while (currentIndex < buffer.Length)
             {
                 TLVEntity entity = new TLVEntity();
                 //1. 根据Tag判断数据是否是嵌套的TLV
                 bool hasSubEntity = HasSubEntity(buffer, currentIndex);

                 #region Tag解析
                 entity.Tag = GetTag(buffer, currentIndex);
                 currentIndex += entity.Tag.Length;
                 #endregion

                 #region Length解析
                 entity.Length = GetLength(buffer, currentIndex);
                 currentIndex += entity.Length.Length;
                 #endregion

                 #region Value解析
                 int valueLength = GetValueLengthByLengthByteValue(entity.Length);
                 entity.Value = buffer.Take(currentIndex + valueLength).Skip(currentIndex).ToArray();
                 if (hasSubEntity)//判断是否是嵌套结构
                     entity.SubTLVEntity = Construct(entity.Value);//嵌套结构递归解析
                 currentIndex += entity.Value.Length;
                 #endregion

                 resultList.Add(entity);
             }
             return resultList;
         }

         /// <summary>
         /// 是否存在嵌套实体
         /// </summary>
         /// <returns></returns>
         private static bool HasSubEntity(byte[] bytes, int index)
         {
             if (bytes.Length < index + )
                 throw new ArgumentException("无效的索引值");
             return (bytes[index] & 0x20) == 0x20;
         }

         /// <summary>
         /// 获取Tag字节数据
         /// </summary>
         /// <param name="bytes">长度</param>
         /// <param name="index">索引位置</param>
         /// <returns></returns>
         private static byte[] GetTag(byte[] bytes, int index)
         {
             if (bytes.Length < index + )
                 throw new ArgumentException("无效的索引值");
             //判断Tag所占字节长度
             if ((bytes[index] & 0x1f) == 0x1f)
             {//占2字节
                 return new byte[] { bytes[index], bytes[index + ] };
             }
             else
             {//占1字节
                 return new byte[] { bytes[index] };
             }
         }

         /// <summary>
         /// 获取长度
         /// </summary>
         /// <param name="bytes">长度</param>
         /// <param name="index">索引位置</param>
         /// <returns></returns>
         private static byte[] GetLength(byte[] bytes, int index)
         {
             if (bytes.Length < index + )
                 throw new ArgumentException("无效的索引值");
             //判断Length部分所占字节 是1个字节还是多个字节
             if ((bytes[index] & 0x80) == 0x80)
             {//占多个字节
                 int lengthSize = (bytes[index] & 0x7f) + ;//获取Length所占字节数
                 return bytes.Take(index + lengthSize).Skip(index).ToArray();
             }
             else
             {//占单个字节
                 return new byte[] { bytes[index] };
             }
         }
         /// <summary>
         /// 根据Length部分的值获取到value部分的值
         /// </summary>
         /// <param name="bytes">Length部分的值</param>
         /// <returns></returns>
         private static int GetValueLengthByLengthByteValue(byte[] bytes)
         {
             int length = ;
             if (bytes.Length == )
                 length = bytes[];
             else
             {
                 //从下一个字节开始算Length域
                 for (int index = ; index < bytes.Length; index++)
                 {
                     length += bytes[index] << ((index-) * ); //计算Length域的长度
                 }
             }
             return length;
         }

     #endregion

         #region TLV 解析
         /// <summary>
         /// 解析TLV
         /// </summary>
         /// <param name="list">
         /// <returns></returns>
         public static byte[] Parse(List<TLVEntity> list)
         {
             byte[] buffer = new byte[];
             int currentIndex = ;
             int currentTLVIndex = ;
             int valueSize = ;

             while (currentTLVIndex < list.Count())
             {
                 valueSize = ;
                 TLVEntity entity = list[currentTLVIndex];

                 Array.Copy(entity.Tag, , buffer, currentIndex, entity.TagSize);    //解析Tag

                 currentIndex += entity.TagSize;

                 for (int index = ; index < entity.LengthSize; index++)
                 {
                     valueSize += entity.Length[index] << (index * ); //计算Length域的长度
                 }
                 if (valueSize > )
                 {
                     buffer[currentIndex] = Convert.ToByte(0x80 | entity.LengthSize);
                     currentIndex += ;
                 }

                 Array.Copy(entity.Length, , buffer, currentIndex, entity.LengthSize);  //解析Length

                 currentIndex += entity.LengthSize;
                 //判断是否包含子嵌套TLV
                 if (entity.SubTLVEntity == null)
                 {
                     Array.Copy(entity.Value, , buffer, currentIndex, valueSize);   //解析Value
                     currentIndex += valueSize;
                 }
                 else
                 {
                     byte[] tempBuffer = Parse(entity.SubTLVEntity);
                     Array.Copy(tempBuffer, , buffer, currentIndex, tempBuffer.Length); //解析子嵌套TLV
                     currentIndex += tempBuffer.Length;
                 }

                 currentTLVIndex++;
             }

             byte[] resultBuffer = new byte[currentIndex];
             Array.Copy(buffer, , resultBuffer, , currentIndex);

             return resultBuffer;
         }
         #endregion
     }

tlv实体操作帮助类

　　 public class TLVHelper
    {

        /// <summary>
        /// 根据tag获取tlv的值
        /// </summary>
        /// <param name="entities"></param>
        /// <param name="tag"></param>
        /// <returns></returns>
        public static TLVEntity GetValueByTag(List<TLVEntity> entities, string tag)
        {
            TLVEntity resultEntity = null;
            var query = entities.SingleOrDefault(e => CodeConvert.ToHexString(e.Tag).ToUpper() == tag);
            if (query == null)
            {
                foreach (var tlv in entities)
                {
                    if (tlv.SubTLVEntity != null)
                    {
                        TLVEntity result = GetValueByTag(tlv.SubTLVEntity, tag);

                        if (result !=null && result.Length.Length > )
                            return result;
                    }
                }
            }
            else
                resultEntity = query;
            return resultEntity;
        }
        /// <summary>
        /// 16进制数据转化为TVL实体
        /// </summary>
        /// <param name="resultData"></param>
        /// <returns></returns>
        public static List<TLVEntity> ToTLVEntityList(string data)
        {
            byte[] dataBytes = CodeConvert.HexStringToByteArray(data);
            var tlvList = TLVPackage.Construct(dataBytes);
            return tlvList;
        }

    }

转载请注明出处：http://www.cnblogs.com/xinwang/p/5733198.html