金融系统中PBOC/EMV的TLV的算法实现（含C++/C#）

TLV即Tag-Length-Value，常在IC卡与POS终端设备中通过这样的一个应用通信协议进行数据交换。在金融系统以及认证中，PBOC以及 EMV的认证规范文档上面也有对TLV做了一些说明，由于认证规范都是英文文档，所以有些人可能不易于理解。首先我先介绍下什么是TLV，TLV的用途是什么，以及如何实现它的打包解包算法。

金融系统中的TLV是BER-TLV编码的一个特例编码规范，而BER-TLV是ISO定义中的规范。在TLV的定义中，可以知道它包括三个域，分别为：标签域（Tag），长度域（Length），内容域（Value）。这里的长度域的值实际上就是内容域的长度。

其实，在BER编码的方式有两种情况，一种是确定长度的方式，一种是不确定长度的方式，而金融TLV选择了确定长度的方式，这样在设备之间的数据传输量上就可以减少。

Tag域说明：

先来看下TLV的Tag是如何编码的，先看下图：

这张图说明了Tag域第一个字节的编码格式。其中b8-b1代表1个字节中的8个位。

其中b8,b7代表数据的类别。根据2个位的组合，有四种类别：通用类别，应用类别，上下文语境类别，专用类别。这个主要用于在于终端设备交互的时候，确定数据处理的类型。

b6代表的是数据元结构，也就是说它是属于简单数据元结构，还是属于结构（复合）数据元结构。当b6为1的时候，就需要后续的字节进行扩展。也就是说复合的TLV中，value域里也包含一个或多个TLV，这个稍后接着介绍。

当b5-b1代表串行号，当5个位都为1时，需要将tag域扩展到下一个字节中，也就是Tag占2个字节；而当5个位都不全为1时，该Tag域就只占1个字节。

现在，看下b5-b1：11111的情况：

从图中我们看到BER-TLV编码中，当b8为1时，Tag还需要有后续字节，直到b8为0为止。从EMV文档中的说明，Tag最多只占用2个字节，所以这样就相对比较简单一些了。当b8为0时，该Tag域结束，总共就占用2个字节。

Length域说明：

在文档中没有图片叙述，我自绘一个：

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

Value域说明：

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

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

Tag就是Tag,没有子标签Tag，基本结构就是T-L-V。

再看下符合数据元结构：

后面的Value说明：Primitive or constructed BER-TLV data object number，包含一个简单数据元结构或者也可以是一个符合数据元结构。这样可以看出，算法中必须要实现Tag的嵌套功能，递归算法不可少。

算法实现：

根据以上的说明现在来实现它的打包解包的算法（打包的目的是将一个从终端上发的请求数据——字节数组，构造成一系列的TLV结构实体；解包的目的刚好相反，就是将TLV结构实体解析成字节数组，然后通过IC卡发送到终端上）。

首先定义一个TLV结构实体：

1
// TLV结构体

2
struct TLVEntity {

3
    unsigned char* Tag;         //标记

4
    unsigned char* Length;      //数据长度

5
    unsigned char* Value;       //数据

6
    unsigned int TagSize;       //标记占用字节数

7
    unsigned int LengthSize;    //数据长度占用字节数

8
    TLVEntity* Sub_TLVEntity;   //子嵌套TLV实体

9
};

其中TagSize代表Tag字段的字节长度，LengthSize代表Length的字节长度，这里的Length记住要使用char*，由于前面说过，Length可能包含多个字节，通过多个字节确定Value域的长度，Sub_TLVEntity作为子嵌套的TLV结构体。

定义一个TLVPackage的打包类：

TLVPackage.h：

01
// TLV打包类

02
class TLVPackage

03
{

04
public:

05
    TLVPackage();

06
    virtual ~TLVPackage();

07
    //构造TLV实体

08
    static void Construct(unsigned char* buffer, unsigned int bufferLength, TLVEntity* tlvEntity, unsigned int& entityLength, unsigned int status=0);

09
    //解析TLV字节数组

10
    static void Parse(TLVEntity* tlvEntity, unsigned int entityLength, unsigned char* buffer, unsigned int& bufferLength);

11
};

具体方法实现：

001
// 构造TLV

002
void TLVPackage:: Construct(

003
    unsigned char* buffer, 

004
    unsigned int bufferLength, 

005
    TLVEntity* tlvEntity, 

006
    unsigned int& entityLength,

007
    unsigned int status

008
    )

009
{

010
    int currentTLVIndex = 0;

011
    int currentIndex = 0;

012
    int currentStatus = 'T'; //状态字符

013
    unsigned long valueSize = 0;

014
 
015
    while(currentIndex < bufferLength)

016
    {

017
        switch(currentStatus)

018
        {

019
        case 'T':

020
            valueSize = 0;

021
            //判断是否单一结构

022
            if((status == 1 && buffer[currentIndex] & 0x20) != 0x20)

023
            {

024
                tlvEntity[currentTLVIndex].Sub_TLVEntity = NULL; //单一结构时将子Tag置空

025
                //判断是否多字节Tag

026
                if((buffer[currentIndex] & 0x1f) == 0x1f)

027
                {

028
                    int endTagIndex = currentIndex;

029
                    while((buffer[++endTagIndex] & 0x80) == 0x80); //判断第二个字节的最高位是否为1

030
                    int tagSize = endTagIndex - currentIndex + 1; //计算Tag包含多少字节

031
 
032
                    tlvEntity[currentTLVIndex].Tag = new unsigned char[tagSize];

033
                    memcpy(tlvEntity[currentTLVIndex].Tag, buffer + currentIndex, tagSize); 

034
                    tlvEntity[currentTLVIndex].Tag[tagSize] = 0;

035
 
036
                    tlvEntity[currentTLVIndex].TagSize = tagSize;

037
 
038
                    currentIndex += tagSize;

039
                }

040
                else

041
                {

042
                    tlvEntity[currentTLVIndex].Tag = new unsigned char[1];

043
                    memcpy(tlvEntity[currentTLVIndex].Tag, buffer + currentIndex, 1);

044
                    tlvEntity[currentTLVIndex].Tag[1] = 0;

045
 
046
                    tlvEntity[currentTLVIndex].TagSize = 1;

047
 
048
                    currentIndex += 1;

049
                }

050
            }

051
            else

052
            {

053
                //判断是否多字节Tag

054
                if((buffer[currentIndex] & 0x1f) == 0x1f)

055
                {

056
                    int endTagIndex = currentIndex;

057
                    while((buffer[++endTagIndex] & 0x80) == 0x80); //判断第二个字节的最高位是否为1

058
                    int tagSize = endTagIndex - currentIndex + 1; //计算Tag包含多少字节

059
 
060
                    tlvEntity[currentTLVIndex].Tag = new unsigned char[tagSize];

061
                    memcpy(tlvEntity[currentTLVIndex].Tag, buffer + currentIndex, tagSize); 

062
                    tlvEntity[currentTLVIndex].Tag[tagSize] = 0;

063
 
064
                    tlvEntity[currentTLVIndex].TagSize = tagSize;

065
 
066
                    currentIndex += tagSize;

067
                }

068
                else

069
                {

070
                    tlvEntity[currentTLVIndex].Tag = new unsigned char[1];

071
                    memcpy(tlvEntity[currentTLVIndex].Tag, buffer + currentIndex, 1);

072
                    tlvEntity[currentTLVIndex].Tag[1] = 0;

073
 
074
                    tlvEntity[currentTLVIndex].TagSize = 1;

075
 
076
                    currentIndex += 1;              

077
                }

078
 
079
                //分析SubTag

080
                int subLength = 0;  

081
                 
082
                unsigned char* temp;

083
                if((buffer[currentIndex] & 0x80) == 0x80)

084
                {

085
                    for (int index = 0; index < 2; index++)

086
                    {

087
                        subLength += buffer[currentIndex + 1 + index] << (index * 8); //计算Length域的长度

088
                    }

089
 
090
                    temp = new unsigned char[subLength];

091
 
092
                    memcpy(temp, buffer + currentIndex + 3, subLength);

093
                }

094
                else

095
                {

096
                    subLength = buffer[currentIndex];

097
 
098
                    temp = new unsigned char[subLength];

099
 
100
                    memcpy(temp, buffer + currentIndex + 1, subLength);

101
                }

102
                temp[subLength] = 0;

103
                 
104
                //memcpy(temp, buffer + currentIndex + 1, subLength);

105
                unsigned int oLength;

106
                tlvEntity[currentTLVIndex].Sub_TLVEntity = new TLVEntity[1];

107
                Construct(temp, subLength, tlvEntity[currentTLVIndex].Sub_TLVEntity, oLength);

108
            }

109
 
110
            currentStatus = 'L';

111
            break;

112
        case 'L':       

113
            //判断长度字节的最高位是否为1，如果为1，则该字节为长度扩展字节，由下一个字节开始决定长度

114
            if((buffer[currentIndex] & 0x80) != 0x80)

115
            {

116
                tlvEntity[currentTLVIndex].Length = new unsigned char[1];

117
                memcpy(tlvEntity[currentTLVIndex].Length, buffer + currentIndex, 1);

118
                tlvEntity[currentTLVIndex].Length[1] = 0;

119
                tlvEntity[currentTLVIndex].LengthSize = 1;

120
 
121
                valueSize = tlvEntity[currentTLVIndex].Length[0];

122
 
123
                currentIndex += 1;

124
            }

125
            else

126
            {

127
                //为1的情况

128
 
129
                unsigned int lengthSize = buffer[currentIndex] & 0x7f;

130
                 
131
                currentIndex += 1; //从下一个字节开始算Length域

132
 
133
                for (int index = 0; index < lengthSize; index++)

134
                {

135
                    valueSize += buffer[currentIndex + index] << (index * 8); //计算Length域的长度

136
                }

137
 
138
                tlvEntity[currentTLVIndex].Length = new unsigned char[lengthSize];

139
                memcpy(tlvEntity[currentTLVIndex].Length, buffer + currentIndex, lengthSize);

140
                tlvEntity[currentTLVIndex].Length[lengthSize] = 0;

141
 
142
                tlvEntity[currentTLVIndex].LengthSize = lengthSize;

143
 
144
                currentIndex += lengthSize;

145
            }

146
 
147
            currentStatus = 'V';

148
            break;

149
        case 'V':

150
            tlvEntity[currentTLVIndex].Value = new unsigned char[valueSize];

151
            memcpy(tlvEntity[currentTLVIndex].Value, buffer + currentIndex, valueSize);

152
            tlvEntity[currentTLVIndex].Value[valueSize] = 0;

153
 
154
            currentIndex += valueSize;

155
             
156
            //进入下一个TLV构造循环

157
            currentTLVIndex += 1;

158
 
159
            currentStatus = 'T';

160
            break;

161
        default:

162
            return;

163
        }

164
    }

165
 
166
    entityLength = currentTLVIndex;

167
}

168
 
169
// 解析TLV

170
void TLVPackage::Parse(

171
    TLVEntity* tlvEntity, 

172
    unsigned int entityLength, 

173
    unsigned char* buffer, 

174
    unsigned int& bufferLength

175
    )

176
{

177
    int currentIndex = 0;

178
    int currentTLVIndex = 0;

179
    unsigned long valueSize = 0;

180
 
181
    while(currentTLVIndex < entityLength)

182
    {

183
        valueSize = 0;

184
        TLVEntity entity = tlvEntity[currentTLVIndex];

185
         
186
        memcpy(buffer + currentIndex, entity.Tag, entity.TagSize);  //解析Tag

187
        currentIndex += entity.TagSize;

188
 
189
        for (int index = 0; index < entity.LengthSize; index++)

190
        {

191
            valueSize += entity.Length[index] << (index * 8); //计算Length域的长度

192
        }

193
        if(valueSize > 127)

194
        {

195
            buffer[currentIndex] = 0x80 | entity.LengthSize;

196
            currentIndex += 1;

197
        }

198
         
199
        memcpy(buffer + currentIndex, entity.Length, entity.LengthSize);    //解析Length

200
        currentIndex += entity.LengthSize;

201
        //判断是否包含子嵌套TLV

202
        if(entity.Sub_TLVEntity == NULL)

203
        {

204
            memcpy(buffer + currentIndex, entity.Value, valueSize); //解析Value

205
            currentIndex += valueSize;

206
        }

207
        else

208
        {

209
            unsigned int oLength;

210
            Parse(entity.Sub_TLVEntity, 1, buffer + currentIndex, oLength); //解析子嵌套TLV

211
            currentIndex += oLength;

212
        }

213
 
214
        currentTLVIndex++;

215
    }

216
    buffer[currentIndex] = 0;

217
    bufferLength = currentIndex;

218
}

然后写测试程序：

01
// 上发测试数据

02
unsigned char requestBuf[] = {

03
        0x9F, 0x1C, 0x12, 0x33, 0x33, 0x30, 0x32, 0x32, 0x37, 0x31, 0x39, 0x36, 0x32, 0x30, 0x34, 0x30, 0x34, 

04
        0x32, 0x37, 0x31, 0x38, 0x9F, 0x62, 0x01, 0x01, 0x57, 0x12, 0x62, 0x22, 0x89, 0x00, 0x00, 0x02, 0x91, 

05
        0x01, 0xD0, 0x90, 0x32, 0x01, 0x02, 0x47, 0x17, 0x13, 0x00, 0x0F, 0x5F, 0x20, 0x0A, 0x48, 0x55, 0x47, 

06
        0x55, 0x4F, 0x20, 0x4D, 0x49, 0x4E, 0x47, 0x9F, 0x1F, 0x3C, 0x25, 0x39, 0x39, 0x36, 0x32, 0x32, 0x32, 

07
        0x38, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x39, 0x31, 0x30, 0x31, 0x5E, 0x47, 0x55, 0x4F, 0x20, 

08
        0x4D, 0x49, 0x4E, 0x47, 0x2F, 0x48, 0x55, 0x5E, 0x30, 0x39, 0x30, 0x33, 0x32, 0x30, 0x31, 0x30, 0x32, 

09
        0x34, 0x37, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x38, 0x39, 0x30, 

10
        0x30, 0x3F

11
}; 

12
 
13
    TLVEntity tlvEntity[TLV_MAX_LENGTH];

14
    unsigned int tlv_count;

15
    //构造TLV

16
    TLVPackage::Construct(requestBuf, sizeof(requestBuf), tlvEntity, tlv_count);

17
 
18
    unsigned char parseBuf[1024];

19
    unsigned int buf_count;

20
    //解析TLV

21
    TLVPackage::Parse(tlvEntity, tlv_count, parseBuf, buf_count);

22
 
23
    if(strncmp((char*)parseBuf, (char*)requestBuf, sizeof(requestBuf)) == 0)

24
    {

25
        AfxMessageBox("TRUE");

26
    }

27
    else

28
    {

29
        AfxMessageBox("FALSE");

30
    }

最后测试结果中，可以得到最后将弹出“TRUE”的对话框。证明构造TLV得到的TLVEntity，再对这个实体进行解析，可以的到解析后的字节数组，最后通过strncmp的方法比较判断，是否原始字节数组和解析后的字节数组是否一致。

另外，为了方便C#程序员的使用，我对该C++程序重新改写了一下，得出的结果也是一样的。

TLVEntity.cs

01
/// <summary>

02
    /// TLV实体

03
    /// </summary>

04
    public class TLVEntity

05
    {

06
        /// <summary>

07
        /// 标记

08
        /// </summary>

09
        public byte[] Tag { get; set; }

10
 
11
        /// <summary>

12
        /// 数据长度

13
        /// </summary>

14
        public byte[] Length { get; set; }

15
 
16
        /// <summary>

17
        /// 数据

18
        /// </summary>

19
        public byte[] Value { get; set; }

20
 
21
        /// <summary>

22
        /// 标记占用字节数

23
        /// </summary>

24
        public int TagSize { get; set; }

25
 
26
        /// <summary>

27
        /// 数据长度占用字节数

28
        /// </summary>

29
        public int LengthSize { get; set; }

30
 
31
        /// <summary>

32
        /// 子嵌套TLV实体

33
        /// </summary>

34
        public TLVEntity Sub_TLVEntity { get; set; }

35
    }

以及TLVPackage.cs

001
/// <summary>

002
    /// TLV打包类

003
    /// </summary>

004
    public class TLVPackage

005
    {

006
        /// <summary>

007
        /// 构造TLV

008
        /// </summary>

009
        /// <param name="buffer">

010
        public static List<tlventity> Construct(byte[] buffer)

011
        {

012
            List<tlventity> list = new List<tlventity>();

013
            int currentTLVIndex = 0;

014
            int currentIndex = 0;

015
            int currentStatus = 'T'; //状态字符

016
            int valueSize = 0;

017
 
018
            TLVEntity tlvEntity = null;

019
 
020
            while (currentIndex < buffer.Length)

021
            {

022
                switch (currentStatus)

023
                {

024
                    case 'T':

025
                        tlvEntity = new TLVEntity();

026
                        valueSize = 0;

027
                        //判断是否单一结构

028
                        if ((buffer[currentIndex] & 0x20) != 0x20)

029
                        {

030
                            tlvEntity.Sub_TLVEntity = null; //单一结构时将子Tag置空【】

031
                            //判断是否多字节Tag

032
                            if ((buffer[currentIndex] & 0x1f) == 0x1f)

033
                            {

034
                                int endTagIndex = currentIndex;

035
                                while ((buffer[++endTagIndex] & 0x80) == 0x80) ; //判断第二个字节的最高位是否为1

036
                                int tagSize = endTagIndex - currentIndex + 1; //计算Tag包含多少字节

037
 
038
                                tlvEntity.Tag = new byte[tagSize];

039
                                Array.Copy(buffer, currentIndex, tlvEntity.Tag, 0, tagSize);

040
 
041
                                tlvEntity.TagSize = tagSize;

042
 
043
                                currentIndex += tagSize;

044
                            }

045
                            else

046
                            {

047
                                tlvEntity.Tag = new byte[1];

048
                                Array.Copy(buffer, currentIndex, tlvEntity.Tag, 0, 1);

049
 
050
                                tlvEntity.TagSize = 1;

051
 
052
                                currentIndex += 1;

053
                            }

054
                        }

055
                        else

056
                        {

057
                            //判断是否多字节Tag

058
                            if ((buffer[currentIndex] & 0x1f) == 0x1f)

059
                            {

060
                                int endTagIndex = currentIndex;

061
                                while ((buffer[++endTagIndex] & 0x80) == 0x80) ; //判断第二个字节的最高位是否为1

062
                                int tagSize = endTagIndex - currentIndex + 1; //计算Tag包含多少字节

063
 
064
                                tlvEntity.Tag = new byte[tagSize];

065
                                Array.Copy(buffer, currentIndex, tlvEntity.Tag, 0, tagSize);

066
 
067
                                tlvEntity.TagSize = tagSize;

068
 
069
                                currentIndex += tagSize;

070
                            }

071
                            else

072
                            {

073
                                tlvEntity.Tag = new byte[1];

074
                                Array.Copy(buffer, currentIndex, tlvEntity.Tag, 0, 1);

075
 
076
                                tlvEntity.TagSize = 1;

077
 
078
                                currentIndex += 1;

079
                            }

080
 
081
                            //分析SubTag

082
                            int subLength = 0;

083
 
084
                            byte[] temp;

085
                            if ((buffer[currentIndex] & 0x80) == 0x80)

086
                            {

087
                                for (int index = 0; index < 2; index++)

088
                                {

089
                                    subLength += buffer[currentIndex + 1 + index] << (index * 8); //计算Length域的长度

090
                                }

091
 
092
                                temp = new byte[subLength];

093
 
094
                                Array.Copy(buffer, currentIndex + 3, temp, 0, subLength);

095
                            }

096
                            else

097
                            {

098
                                subLength = buffer[currentIndex];

099
 
100
                                temp = new byte[subLength];

101
 
102
                                Array.Copy(buffer, currentIndex + 1, temp, 0, subLength);

103
                            }

104
 
105
                            int oLength;

106
                            tlvEntity.Sub_TLVEntity = new TLVEntity();

107
                            List<tlventity> tempList = Construct(temp);

108
                            tlvEntity.Sub_TLVEntity = tempList[0];

109
                        }

110
 
111
                        currentStatus = 'L';

112
                        break;

113
                    case 'L':

114
                        //判断长度字节的最高位是否为1，如果为1，则该字节为长度扩展字节，由下一个字节开始决定长度

115
                        if ((buffer[currentIndex] & 0x80) != 0x80)

116
                        {

117
                            tlvEntity.Length = new byte[1];

118
                            Array.Copy(buffer, currentIndex, tlvEntity.Length, 0, 1);

119
 
120
                            tlvEntity.LengthSize = 1;

121
 
122
                            valueSize = tlvEntity.Length[0];

123
                            currentIndex += 1;

124
                        }

125
                        else

126
                        {

127
                            //为1的情况

128
 
129
                            int lengthSize = buffer[currentIndex] & 0x7f;

130
 
131
                            currentIndex += 1; //从下一个字节开始算Length域

132
 
133
                            for (int index = 0; index < lengthSize; index++)

134
                            {

135
                                valueSize += buffer[currentIndex + index] << (index * 8); //计算Length域的长度

136
                            }

137
 
138
                            tlvEntity.Length = new byte[lengthSize];

139
                            Array.Copy(buffer, currentIndex, tlvEntity.Length, 0, lengthSize);

140
 
141
                            tlvEntity.LengthSize = lengthSize;

142
 
143
                            currentIndex += lengthSize;

144
                        }

145
 
146
                        currentStatus = 'V';

147
                        break;

148
                    case 'V':

149
                        tlvEntity.Value = new byte[valueSize];

150
                        Array.Copy(buffer, currentIndex, tlvEntity.Value, 0, valueSize);

151
 
152
                        currentIndex += valueSize;

153
 
154
                        //进入下一个TLV构造循环

155
                        list.Add(tlvEntity);

156
 
157
                        currentStatus = 'T';

158
                        break;

159
                    default:

160
                        return new List<tlventity>();

161
                }

162
            }

163
 
164
            return list;

165
        }

166
 
167
        /// <summary>

168
        /// 解析TLV

169
        /// </summary>

170
        /// <param name="list">

171
        /// <returns></returns>

172
        public static byte[] Parse(List<tlventity> list)

173
        {

174
            byte[] buffer = new byte[4096];

175
            int currentIndex = 0;

176
            int currentTLVIndex = 0;

177
            int valueSize = 0;

178
 
179
            while (currentTLVIndex < list.Count())

180
            {

181
                valueSize = 0;

182
                TLVEntity entity = list[currentTLVIndex];

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

185
 
186
                currentIndex += entity.TagSize;

187
 
188
                for (int index = 0; index < entity.LengthSize; index++)

189
                {

190
                    valueSize += entity.Length[index] << (index * 8); //计算Length域的长度

191
                }

192
                if (valueSize > 127)

193
                {

194
                    buffer[currentIndex] = Convert.ToByte(0x80 | entity.LengthSize);

195
                    currentIndex += 1;

196
                }

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

199
 
200
                currentIndex += entity.LengthSize;

201
                //判断是否包含子嵌套TLV

202
                if (entity.Sub_TLVEntity == null)

203
                {

204
                    Array.Copy(entity.Value, 0, buffer, currentIndex, valueSize);   //解析Value

205
                    currentIndex += valueSize;

206
                }

207
                else

208
                {

209
                    byte[] tempBuffer = Parse(new List<tlventity> { entity.Sub_TLVEntity });

210
                    Array.Copy(tempBuffer, 0, buffer, currentIndex, tempBuffer.Length); //解析子嵌套TLV

211
                    currentIndex += tempBuffer.Length;

212
                }

213
 
214
                currentTLVIndex++;

215
            }

216
 
217
            byte[] resultBuffer = new byte[currentIndex];

218
            Array.Copy(buffer, 0, resultBuffer, 0, currentIndex);

219
 
220
            return resultBuffer;

221
        }

222
    }</tlventity></tlventity></tlventity></tlventity></tlventity></tlventity></tlventity>

接着，写测试程序：

01
static byte[] requestBuffer = 

02
        {

03
            0x9F, 0x1C, 0x82, 0x2C, 0x01,

04
            0x33,
 0x33, 0x30, 0x32, 0x32, 0x37, 0x31, 0x39, 0x36, 0x32,0x33, 0x33, 0x30, 
0x32, 0x32, 0x37, 0x31, 0x39, 0x36, 0x32,0x33, 0x33, 0x30, 0x32, 0x32, 
0x37, 0x31, 0x39, 0x36, 0x32,

05
            0x33,
 0x33, 0x30, 0x32, 0x32, 0x37, 0x31, 0x39, 0x36, 0x32,0x33, 0x33, 0x30, 
0x32, 0x32, 0x37, 0x31, 0x39, 0x36, 0x32,0x33, 0x33, 0x30, 0x32, 0x32, 
0x37, 0x31, 0x39, 0x36, 0x32,

06
            0x33,
 0x33, 0x30, 0x32, 0x32, 0x37, 0x31, 0x39, 0x36, 0x32,0x33, 0x33, 0x30, 
0x32, 0x32, 0x37, 0x31, 0x39, 0x36, 0x32,0x33, 0x33, 0x30, 0x32, 0x32, 
0x37, 0x31, 0x39, 0x36, 0x32,

07
            0x33,
 0x33, 0x30, 0x32, 0x32, 0x37, 0x31, 0x39, 0x36, 0x32,0x33, 0x33, 0x30, 
0x32, 0x32, 0x37, 0x31, 0x39, 0x36, 0x32,0x33, 0x33, 0x30, 0x32, 0x32, 
0x37, 0x31, 0x39, 0x36, 0x32,

08
            0x33,
 0x33, 0x30, 0x32, 0x32, 0x37, 0x31, 0x39, 0x36, 0x32,0x33, 0x33, 0x30, 
0x32, 0x32, 0x37, 0x31, 0x39, 0x36, 0x32,0x33, 0x33, 0x30, 0x32, 0x32, 
0x37, 0x31, 0x39, 0x36, 0x32,

09
            0x33,
 0x33, 0x30, 0x32, 0x32, 0x37, 0x31, 0x39, 0x36, 0x32,0x33, 0x33, 0x30, 
0x32, 0x32, 0x37, 0x31, 0x39, 0x36, 0x32,0x33, 0x33, 0x30, 0x32, 0x32, 
0x37, 0x31, 0x39, 0x36, 0x32,

10
            0x33,
 0x33, 0x30, 0x32, 0x32, 0x37, 0x31, 0x39, 0x36, 0x32,0x33, 0x33, 0x30, 
0x32, 0x32, 0x37, 0x31, 0x39, 0x36, 0x32,0x33, 0x33, 0x30, 0x32, 0x32, 
0x37, 0x31, 0x39, 0x36, 0x32,

11
            0x33,
 0x33, 0x30, 0x32, 0x32, 0x37, 0x31, 0x39, 0x36, 0x32,0x33, 0x33, 0x30, 
0x32, 0x32, 0x37, 0x31, 0x39, 0x36, 0x32,0x33, 0x33, 0x30, 0x32, 0x32, 
0x37, 0x31, 0x39, 0x36, 0x32,

12
            0x33,
 0x33, 0x30, 0x32, 0x32, 0x37, 0x31, 0x39, 0x36, 0x32,0x33, 0x33, 0x30, 
0x32, 0x32, 0x37, 0x31, 0x39, 0x36, 0x32,0x33, 0x33, 0x30, 0x32, 0x32, 
0x37, 0x31, 0x39, 0x36, 0x32,

13
            0x33,
 0x33, 0x30, 0x32, 0x32, 0x37, 0x31, 0x39, 0x36, 0x32,0x33, 0x33, 0x30, 
0x32, 0x32, 0x37, 0x31, 0x39, 0x36, 0x32,0x33, 0x33, 0x30, 0x32, 0x32, 
0x37, 0x31, 0x39, 0x36, 0x32,

14
            0x71, 0x07, 0x9f, 0x19, 0x04, 0x11, 0x22, 0x33, 0x44

15
        };

16
 
17
        static void Main(string[] args)

18
        {

19
            Console.WriteLine("待组装的数据包：");

20
            requestBuffer.ToList().ForEach(o => { Console.Write("{0},", "0x" + o.ToString("X")); });

21
 
22
            Console.WriteLine("\r\n\r\n开始构造TLV");

23
            //构造TLV

24
            List<tlventity> list = TLVPackage.Construct(requestBuffer);

25
            Console.WriteLine("\r\n构造结束!");

26
 
27
            Console.WriteLine("\r\n开始解析TLV");

28
            //解析TLV

29
            byte[] responseBuffer = TLVPackage.Parse(list);

30
            Console.WriteLine("\r\n解析结束!");

31
 
32
            Console.WriteLine("\r\n解析结果：");

33
 
34
            if (ByteEquals(requestBuffer, responseBuffer))

35
            {

36
                Console.WriteLine("Equal!");

37
            }

38
            else

39
            {

40
                Console.WriteLine("Not Equal!");

41
            }

42
 
43
            Console.ReadKey();

44
        }</tlventity>

运行结果：

总结

TLV在数据通信方面，其实运用得很广泛，在应用层数据通信中，如HTTP协议，HTML，XML语言本身定义了一些标签（Body，Head，Script）对数据串行化，接收方再根据标签解析原始数据，通过浏览器展现出来。因此本质上也是属于TLV协议的设计模式。甚至在传输层的TCP，UDP协议，你完全可以通过TLV实现自定义的应用协议。

附上C#源代码：TLVPackageDemo.rar

作者：Leepy

邮箱：sunleepy(AT)gmail.com

出处：http://liping13599168.cnblogs.com/

本文版权归作者和博客园共有，欢迎转载，但未经作者同意必须保留此段声明，且在文章页面明显位置给出原文链接，否则保留追究法律责任的权利。

posted on 2011-06-16 09:21 HackerVirus 阅读(288) 评论(0) 编辑收藏举报

刷新页面返回顶部

公告

导航

金融系统中PBOC/EMV的TLV的算法实现（含C++/C#）