这应该是相当基础的问题，但我已经困扰了一段时间，所以我想问问周围的人，提前感谢您的帮助。
我的问题是，我有这个序列：
User::=SEQUENCE {
userid [0] IA5String,
password [1] Implicit IA5String}
我想使用BER对以下内容进行编码，具体数值如下：
{userid = "user", password = "pass"}
所以我们有三个“字段”TLV：
Tag is: 001 10000
我的问题是长度本身，应该是08（我认为来自“用户”的04字节加上来自“密码”的04字节）。
但是在解决方案中，我看到：
L -> 0 0 0 0 1 1 1 0 (=14) 0E
User::=SEQUENCE {
userid [0] IA5String,
password [1] IMPLICIT IA5String}
以及您的数据价值
{userid = "user", password = "pass"}
userid 字段进行编码。这是一个标记类型，这里取决于全局的 EXPLICIT 或 IMPLICIT 选项，它可能是构建或非构建的：
- 如果是 EXPLICIT，则会有标记为 0xA0 的标签（用于构建上下文 0），然后是长度和标记类型：IA5String 是标签 0x16（UNIVERSAL 22），其长度为 0x04，其值为 0x75 73 65 72
- 如果是 IMPLICIT，则会有标记为 0x80 的标签（用于非构建上下文 0），长度为 0x04，值为 75 73 65 7230 0c
80 04 75 73 65 72
81 04 70 61 73 73
总计14字节
或者如果是全局EXPLICIT
30 0e
A0 06
16 04 75 73 65 72
81 04 70 61 73 73
总共有16个字节
30 CONSTRUCTED SEQUENCE
0e Length 14
a0 CONSTRUCTED TAGGED 0
06 Length 6
16 IA5String
04 Length 4
75 'u'
73 's'
65 'e'
72 'r'
81 TAGGED 1
04 Length 4
70 'p'
61 'a'
73 's'
73 's'
package binaryhex;
public class BinaryHex {
public static void main(String[] args) {
String s = "A8 59 A0 47 A0 15 80 01 01 81 02 01 F4 82 01 01 83 09 31 32 37 2E 30 2E 30 2E 31 81 07 32 33 30 5F 32 32 37 82 0E 32 30 31 36 30 38 32 32 31 34 35 36 31 30 83 01 00 84 01 00 A5 0F 80 03 44 53 4D 81 08 31 32 33 34 35 36 37 38 81 0E 32 30 31 36 30 38 32 32 31 34 35 36 31 30";
String hexDumpStrWithoutSpace = s.replaceAll("\\s+", "");
int length = calculateLength(hexDumpStrWithoutSpace);
System.out.println("LENGTH: " + length);
}
private static int calculateLength(String hexDumpStrWithoutSpace) {
int decimalValue = 0;
boolean tag = false;
int i = 0;
while (!tag) {
String typeSub = hexDumpStrWithoutSpace.substring(i, i + 2);
StringBuilder typeBinSB = new StringBuilder();
for (int j = 0; j < typeSub.length(); j++) {
typeBinSB.append(hexToBinary("" + typeSub.charAt(j)));
}
String typeBin = typeBinSB.toString();
if (typeBin.charAt(2) == '0') {
int tagInt = Integer.parseInt(typeBin.substring(3), 2);
System.out.println("TAG: " + tagInt);
tag = true;
} else {
String tagStr = typeBin.substring(3 - i / 2);
if (tagStr.equals("11111")) {
i = i + 2;
continue;
} else {
int tagInt = Integer.parseInt(tagStr, 2);
System.out.println("TAG: " + tagInt);
tag = true;
i = i + 2;
}
}
}
for (; i < hexDumpStrWithoutSpace.length();) {
String lengthSub = hexDumpStrWithoutSpace.substring(i, i + 2);
StringBuilder lengthBinSB = new StringBuilder();
for (int j = 0; j < lengthSub.length(); j++) {
lengthBinSB.append(hexToBinary("" + lengthSub.charAt(j)));
}
String lengthBin = lengthBinSB.toString();
if (lengthBin.charAt(0) == '0') {
Integer lengthInt = Integer.parseInt(lengthBin, 2);
decimalValue = lengthInt + i;
break;
} else {
Integer lengthOctets = Integer.parseInt(lengthBin.substring(1), 2);
StringBuilder toBinSB = new StringBuilder();
for (int k = 0; k < lengthOctets; k++) {
i = i + 2;
String toBin = hexDumpStrWithoutSpace.substring(i, i + 2);
for (int j = 0; j < toBin.length(); j++) {
toBinSB.append(hexToBinary("" + toBin.charAt(j)));
}
}
String lengthResult = toBinSB.toString();
Integer lengthValue = Integer.parseInt(lengthResult, 2);
decimalValue = lengthValue + i - 2;
break;
}
}
return decimalValue;
}
static String hexToBinary(String hex) {
int i = Integer.parseInt(hex, 16);
String bin = Integer.toBinaryString(i);
if (bin.length() < 4) {
while (bin.length() < 4) {
bin = "0" + bin;
}
}
return bin;
}
}
01，因为45 = 101101，因此只有1个八位字节。感谢你的帮助！ - RedFoxxieTAG - 000 00010 (02) Length - 000 00001（01，因为45小于1个八位字节） Value - 00101101（45）我的问题是，“用户”和“密码”都有4个字节的长度。
因此，有效负载应该是8个字节，但实际上是14个字节。我想知道如何查看剩余的6个字节来自哪里以及原因。在第一个问题上：
TAG - 001 10000（16-SEQUENCE） 长度 - 它是000 01110，但是怎么会这样？谢谢 - RedFoxxie