1 /*
2 * Copyright (c) 1997, 2011, Oracle and/or its affiliates. All rights reserved.
3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4 *
5 * This code is free software; you can redistribute it and/or modify it
6 * under the terms of the GNU General Public License version 2 only, as
7 * published by the Free Software Foundation. Oracle designates this
8 * particular file as subject to the "Classpath" exception as provided
9 * by Oracle in the LICENSE file that accompanied this code.
10 *
11 * This code is distributed in the hope that it will be useful, but WITHOUT
12 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
13 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
14 * version 2 for more details (a copy is included in the LICENSE file that
15 * accompanied this code).
16 *
17 * You should have received a copy of the GNU General Public License version
18 * 2 along with this work; if not, write to the Free Software Foundation,
19 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
20 *
21 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
22 * or visit www.oracle.com if you need additional information or have any
23 * questions.
24 */
25
26 package sun.security.util;
27
28 import java.security.*;
29 import java.util.HashMap;
30 import java.io.ByteArrayOutputStream;
31
32 /**
33 * This class is used to compute digests on sections of the Manifest.
34 */
35 public class ManifestDigester {
36
37 public static final String MF_MAIN_ATTRS = "Manifest-Main-Attributes";
38
39 /** the raw bytes of the manifest */
40 private byte rawBytes[];
41
42 /** the offset/length pair for a section */
43 private HashMap<String, Entry> entries; // key is a UTF-8 string
44
45 /** state returned by findSection */
46 static class Position {
47 int endOfFirstLine; // not including newline character
48
49 int endOfSection; // end of section, not including the blank line
50 // between sections
51 int startOfNext; // the start of the next section
52 }
53
54 /**
55 * find a section in the manifest.
56 *
57 * @param offset should point to the starting offset with in the
58 * raw bytes of the next section.
59 *
60 * @pos set by
61 *
62 * @returns false if end of bytes has been reached, otherwise returns
63 * true
64 */
65 @SuppressWarnings("fallthrough")
66 private boolean findSection(int offset, Position pos)
67 {
68 int i = offset, len = rawBytes.length;
69 int last = offset;
70 int next;
71 boolean allBlank = true;
72
73 pos.endOfFirstLine = -1;
74
75 while (i < len) {
76 byte b = rawBytes[i];
77 switch(b) {
78 case '\r':
79 if (pos.endOfFirstLine == -1)
80 pos.endOfFirstLine = i-1;
81 if ((i < len) && (rawBytes[i+1] == '\n'))
82 i++;
83 /* fall through */
84 case '\n':
85 if (pos.endOfFirstLine == -1)
86 pos.endOfFirstLine = i-1;
87 if (allBlank || (i == len-1)) {
88 if (i == len-1)
89 pos.endOfSection = i;
90 else
91 pos.endOfSection = last;
92 pos.startOfNext = i+1;
93 return true;
94 }
95 else {
96 // start of a new line
97 last = i;
98 allBlank = true;
99 }
100 break;
101 default:
102 allBlank = false;
103 break;
104 }
105 i++;
106 }
107 return false;
108 }
109
110 public ManifestDigester(byte bytes[])
111 {
112 rawBytes = bytes;
113 entries = new HashMap<String, Entry>();
114
115 ByteArrayOutputStream baos = new ByteArrayOutputStream();
116
117 Position pos = new Position();
118
119 if (!findSection(0, pos))
120 return; // XXX: exception?
121
122 // create an entry for main attributes
123 entries.put(MF_MAIN_ATTRS,
124 new Entry(0, pos.endOfSection + 1, pos.startOfNext, rawBytes));
125
126 int start = pos.startOfNext;
127 while(findSection(start, pos)) {
128 int len = pos.endOfFirstLine-start+1;
129 int sectionLen = pos.endOfSection-start+1;
130 int sectionLenWithBlank = pos.startOfNext-start;
131
132 if (len > 6) {
133 if (isNameAttr(bytes, start)) {
134 StringBuilder nameBuf = new StringBuilder(sectionLen);
135
136 try {
137 nameBuf.append(
138 new String(bytes, start+6, len-6, "UTF8"));
139
140 int i = start + len;
141 if ((i-start) < sectionLen) {
142 if (bytes[i] == '\r') {
143 i += 2;
144 } else {
145 i += 1;
146 }
147 }
148
149 while ((i-start) < sectionLen) {
150 if (bytes[i++] == ' ') {
151 // name is wrapped
152 int wrapStart = i;
153 while (((i-start) < sectionLen)
154 && (bytes[i++] != '\n'));
155 if (bytes[i-1] != '\n')
156 return; // XXX: exception?
157 int wrapLen;
158 if (bytes[i-2] == '\r')
159 wrapLen = i-wrapStart-2;
160 else
161 wrapLen = i-wrapStart-1;
162
163 nameBuf.append(new String(bytes, wrapStart,
164 wrapLen, "UTF8"));
165 } else {
166 break;
167 }
168 }
169
170 entries.put(nameBuf.toString(),
171 new Entry(start, sectionLen, sectionLenWithBlank,
172 rawBytes));
173
174 } catch (java.io.UnsupportedEncodingException uee) {
175 throw new IllegalStateException(
176 "UTF8 not available on platform");
177 }
178 }
179 }
180 start = pos.startOfNext;
181 }
182 }
183
184 private boolean isNameAttr(byte bytes[], int start)
185 {
186 return ((bytes[start] == 'N') || (bytes[start] == 'n')) &&
187 ((bytes[start+1] == 'a') || (bytes[start+1] == 'A')) &&
188 ((bytes[start+2] == 'm') || (bytes[start+2] == 'M')) &&
189 ((bytes[start+3] == 'e') || (bytes[start+3] == 'E')) &&
190 (bytes[start+4] == ':') &&
191 (bytes[start+5] == ' ');
192 }
193
194 public static class Entry {
195 int offset;
196 int length;
197 int lengthWithBlankLine;
198 byte[] rawBytes;
199 boolean oldStyle;
200
201 public Entry(int offset, int length,
202 int lengthWithBlankLine, byte[] rawBytes)
203 {
204 this.offset = offset;
205 this.length = length;
206 this.lengthWithBlankLine = lengthWithBlankLine;
207 this.rawBytes = rawBytes;
208 }
209
210 public byte[] digest(MessageDigest md)
211 {
212 md.reset();
213 if (oldStyle) {
214 doOldStyle(md,rawBytes, offset, lengthWithBlankLine);
215 } else {
216 md.update(rawBytes, offset, lengthWithBlankLine);
217 }
218 return md.digest();
219 }
220
221 private void doOldStyle(MessageDigest md,
222 byte[] bytes,
223 int offset,
224 int length)
225 {
226 // this is too gross to even document, but here goes
227 // the 1.1 jar verification code ignored spaces at the
228 // end of lines when calculating digests, so that is
229 // what this code does. It only gets called if we
230 // are parsing a 1.1 signed signature file
231 int i = offset;
232 int start = offset;
233 int max = offset + length;
234 int prev = -1;
235 while(i <max) {
236 if ((bytes[i] == '\r') && (prev == ' ')) {
237 md.update(bytes, start, i-start-1);
238 start = i;
239 }
240 prev = bytes[i];
241 i++;
242 }
243 md.update(bytes, start, i-start);
244 }
245
246
247 /** Netscape doesn't include the new line. Intel and JavaSoft do */
248
249 public byte[] digestWorkaround(MessageDigest md)
250 {
251 md.reset();
252 md.update(rawBytes, offset, length);
253 return md.digest();
254 }
255 }
256
257 public Entry get(String name, boolean oldStyle) {
258 Entry e = entries.get(name);
259 if (e != null)
260 e.oldStyle = oldStyle;
261 return e;
262 }
263
264 public byte[] manifestDigest(MessageDigest md)
265 {
266 md.reset();
267 md.update(rawBytes, 0, rawBytes.length);
268 return md.digest();
269 }
270
271 }