1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
|
/*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.apache.tomcat.util.buf;
public class Asn1Writer {
public static byte[] writeSequence(byte[]... components) {
int len = 0;
for (byte[] component : components) {
len += component.length;
}
byte[] combined = new byte[len];
int pos = 0;
for (byte[] component : components) {
System.arraycopy(component, 0, combined, pos, component.length);
pos += component.length;
}
return writeTag((byte) 0x30, combined);
}
public static byte[] writeInteger(int value) {
// How many bytes required to write the value? No more than 4 for int.
int valueSize = 1;
while ((value >> (valueSize * 8)) > 0) {
valueSize++;
}
byte[] valueBytes = new byte[valueSize];
int i = 0;
while (valueSize > 0) {
valueBytes[i] = (byte) (value >> (8 * (valueSize - 1)));
value = value >> 8;
valueSize--;
i++;
}
return writeTag((byte) 0x02, valueBytes);
}
public static byte[] writeOctetString(byte[] data) {
return writeTag((byte) 0x04, data);
}
public static byte[] writeTag(byte tagId, byte[] data) {
int dataSize = data.length;
// How many bytes to write the length?
int lengthSize = 1;
if (dataSize >127) {
// 1 byte we have is now used to record how many bytes we need to
// record a length > 127
// Result is lengthSize = 1 + number of bytes to record length
do {
lengthSize++;
}
while ((dataSize >> (lengthSize * 8)) > 0);
}
// 1 for tag + lengthSize + dataSize
byte[] result = new byte[1 + lengthSize + dataSize];
result[0] = tagId;
if (dataSize < 128) {
result[1] = (byte) dataSize;
} else {
// lengthSize is 1 + number of bytes for length
result[1] = (byte) (127 + lengthSize);
int i = lengthSize;
while (dataSize > 0) {
result[i] = (byte) (dataSize & 0xFF);
dataSize = dataSize >> 8;
i--;
}
}
System.arraycopy(data, 0, result, 1 + lengthSize, data.length);
return result;
}
}
|
