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 = 0;
            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 + 1)
                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 + 1)
                throw new ArgumentException("無效的索引值");
            //判斷Tag所占字節長度
            if ((bytes[index] & 0x1f) == 0x1f)
            {//占2字節
                return new byte[] { bytes[index], bytes[index + 1] };
            }
            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 + 1)
                throw new ArgumentException("無效的索引值");
            //判斷Length部分所占字節 是1個字節還是多個字節
            if ((bytes[index] & 0x80) == 0x80)
            {//占多個字節
                int lengthSize = (bytes[index] & 0x7f) + 1;//獲取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 = 0;
            if (bytes.Length == 1)
                length = bytes[0];
            else
            {
                //從下一個字節開始算Length域
                for (int index = 1; index < bytes.Length; index++)
                {
                    length += bytes[index] << ((index-1) * 8); //計算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[4096];
            int currentIndex = 0;
            int currentTLVIndex = 0;
            int valueSize = 0;

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

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

                currentIndex += entity.TagSize;

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

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

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

                currentTLVIndex++;
            }

            byte[] resultBuffer = new byte[currentIndex];
            Array.Copy(buffer, 0, resultBuffer, 0, 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 > 0)
                            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