1 /*
2 * Copyright (C) 2008 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17 package com.android.signapk;
18
19 import sun.misc.BASE64Encoder;
20 import sun.security.pkcs.ContentInfo;
21 import sun.security.pkcs.PKCS7;
22 import sun.security.pkcs.SignerInfo;
23 import sun.security.x509.AlgorithmId;
24 import sun.security.x509.X500Name;
25
26 import java.io.BufferedReader;
27 import java.io.ByteArrayOutputStream;
28 import java.io.DataInputStream;
29 import java.io.File;
30 import java.io.FileInputStream;
31 import java.io.FileOutputStream;
32 import java.io.FilterOutputStream;
33 import java.io.IOException;
34 import java.io.InputStream;
35 import java.io.InputStreamReader;
36 import java.io.OutputStream;
37 import java.io.PrintStream;
38 import java.security.AlgorithmParameters;
39 import java.security.DigestOutputStream;
40 import java.security.GeneralSecurityException;
41 import java.security.Key;
42 import java.security.KeyFactory;
43 import java.security.MessageDigest;
44 import java.security.PrivateKey;
45 import java.security.Signature;
46 import java.security.SignatureException;
47 import java.security.cert.Certificate;
48 import java.security.cert.CertificateFactory;
49 import java.security.cert.X509Certificate;
50 import java.security.spec.InvalidKeySpecException;
51 import java.security.spec.KeySpec;
52 import java.security.spec.PKCS8EncodedKeySpec;
53 import java.util.ArrayList;
54 import java.util.Collections;
55 import java.util.Date;
56 import java.util.Enumeration;
57 import java.util.List;
58 import java.util.Map;
59 import java.util.TreeMap;
60 import java.util.jar.Attributes;
61 import java.util.jar.JarEntry;
62 import java.util.jar.JarFile;
63 import java.util.jar.JarOutputStream;
64 import java.util.jar.Manifest;
65 import java.util.regex.Pattern;
66 import javax.crypto.Cipher;
67 import javax.crypto.EncryptedPrivateKeyInfo;
68 import javax.crypto.SecretKeyFactory;
69 import javax.crypto.spec.PBEKeySpec;
70
71 /**
72 * Command line tool to sign JAR files (including APKs and OTA updates) in
73 * a way compatible with the mincrypt verifier, using SHA1 and RSA keys.
74 */
75 class SignApk {
76 private static final String CERT_SF_NAME = "META-INF/CERT.SF";
77 private static final String CERT_RSA_NAME = "META-INF/CERT.RSA";
78
79 // Files matching this pattern are not copied to the output.
80 private static Pattern stripPattern =
81 Pattern.compile("^META-INF/(.*)[.](SF|RSA|DSA)$");
82
83 private static X509Certificate readPublicKey(File file)
84 throws IOException, GeneralSecurityException {
85 FileInputStream input = new FileInputStream(file);
86 try {
87 CertificateFactory cf = CertificateFactory.getInstance("X.509");
88 return (X509Certificate) cf.generateCertificate(input);
89 } finally {
90 input.close();
91 }
92 }
93
94 /**
95 * Reads the password from stdin and returns it as a string.
96 *
97 * @param keyFile The file containing the private key. Used to prompt the user.
98 */
99 private static String readPassword(File keyFile) {
100 // TODO: use Console.readPassword() when it's available.
101 System.out.print("Enter password for " + keyFile + " (password will not be hidden): ");
102 System.out.flush();
103 BufferedReader stdin = new BufferedReader(new InputStreamReader(System.in));
104 try {
105 return stdin.readLine();
106 } catch (IOException ex) {
107 return null;
108 }
109 }
110
111 /**
112 * Decrypt an encrypted PKCS 8 format private key.
113 *
114 * Based on ghstark's post on Aug 6, 2006 at
115 * http://forums.sun.com/thread.jspa?threadID=758133&messageID=4330949
116 *
117 * @param encryptedPrivateKey The raw data of the private key
118 * @param keyFile The file containing the private key
119 */
120 private static KeySpec decryptPrivateKey(byte[] encryptedPrivateKey, File keyFile)
121 throws GeneralSecurityException {
122 EncryptedPrivateKeyInfo epkInfo;
123 try {
124 epkInfo = new EncryptedPrivateKeyInfo(encryptedPrivateKey);
125 } catch (IOException ex) {
126 // Probably not an encrypted key.
127 return null;
128 }
129
130 char[] password = readPassword(keyFile).toCharArray();
131
132 SecretKeyFactory skFactory = SecretKeyFactory.getInstance(epkInfo.getAlgName());
133 Key key = skFactory.generateSecret(new PBEKeySpec(password));
134
135 Cipher cipher = Cipher.getInstance(epkInfo.getAlgName());
136 cipher.init(Cipher.DECRYPT_MODE, key, epkInfo.getAlgParameters());
137
138 try {
139 return epkInfo.getKeySpec(cipher);
140 } catch (InvalidKeySpecException ex) {
141 System.err.println("signapk: Password for " + keyFile + " may be bad.");
142 throw ex;
143 }
144 }
145
146 /** Read a PKCS 8 format private key. */
147 private static PrivateKey readPrivateKey(File file)
148 throws IOException, GeneralSecurityException {
149 DataInputStream input = new DataInputStream(new FileInputStream(file));
150 try {
151 byte[] bytes = new byte[(int) file.length()];
152 input.read(bytes);
153
154 KeySpec spec = decryptPrivateKey(bytes, file);
155 if (spec == null) {
156 spec = new PKCS8EncodedKeySpec(bytes);
157 }
158
159 try {
160 return KeyFactory.getInstance("RSA").generatePrivate(spec);
161 } catch (InvalidKeySpecException ex) {
162 return KeyFactory.getInstance("DSA").generatePrivate(spec);
163 }
164 } finally {
165 input.close();
166 }
167 }
168
169 /** Add the SHA1 of every file to the manifest, creating it if necessary. */
170 private static Manifest addDigestsToManifest(JarFile jar)
171 throws IOException, GeneralSecurityException {
172 Manifest input = jar.getManifest();
173 Manifest output = new Manifest();
174 Attributes main = output.getMainAttributes();
175 if (input != null) {
176 main.putAll(input.getMainAttributes());
177 } else {
178 main.putValue("Manifest-Version", "1.0");
179 main.putValue("Created-By", "1.0 (Android SignApk)");
180 }
181
182 BASE64Encoder base64 = new BASE64Encoder();
183 MessageDigest md = MessageDigest.getInstance("SHA1");
184 byte[] buffer = new byte[4096];
185 int num;
186
187 // We sort the input entries by name, and add them to the
188 // output manifest in sorted order. We expect that the output
189 // map will be deterministic.
190
191 TreeMap<String, JarEntry> byName = new TreeMap<String, JarEntry>();
192
193 for (Enumeration<JarEntry> e = jar.entries(); e.hasMoreElements(); ) {
194 JarEntry entry = e.nextElement();
195 byName.put(entry.getName(), entry);
196 }
197
198 for (JarEntry entry: byName.values()) {
199 String name = entry.getName();
200 if (!entry.isDirectory() && !name.equals(JarFile.MANIFEST_NAME) &&
201 !name.equals(CERT_SF_NAME) && !name.equals(CERT_RSA_NAME) &&
202 (stripPattern == null ||
203 !stripPattern.matcher(name).matches())) {
204 InputStream data = jar.getInputStream(entry);
205 while ((num = data.read(buffer)) > 0) {
206 md.update(buffer, 0, num);
207 }
208
209 Attributes attr = null;
210 if (input != null) attr = input.getAttributes(name);
211 attr = attr != null ? new Attributes(attr) : new Attributes();
212 attr.putValue("SHA1-Digest", base64.encode(md.digest()));
213 output.getEntries().put(name, attr);
214 }
215 }
216
217 return output;
218 }
219
220 /** Write to another stream and also feed it to the Signature object. */
221 private static class SignatureOutputStream extends FilterOutputStream {
222 private Signature mSignature;
223
224 public SignatureOutputStream(OutputStream out, Signature sig) {
225 super(out);
226 mSignature = sig;
227 }
228
229 @Override
230 public void write(int b) throws IOException {
231 try {
232 mSignature.update((byte) b);
233 } catch (SignatureException e) {
234 throw new IOException("SignatureException: " + e);
235 }
236 super.write(b);
237 }
238
239 @Override
240 public void write(byte[] b, int off, int len) throws IOException {
241 try {
242 mSignature.update(b, off, len);
243 } catch (SignatureException e) {
244 throw new IOException("SignatureException: " + e);
245 }
246 super.write(b, off, len);
247 }
248 }
249
250 /** Write a .SF file with a digest the specified manifest. */
251 private static void writeSignatureFile(Manifest manifest, OutputStream out)
252 throws IOException, GeneralSecurityException {
253 Manifest sf = new Manifest();
254 Attributes main = sf.getMainAttributes();
255 main.putValue("Signature-Version", "1.0");
256 main.putValue("Created-By", "1.0 (Android SignApk)");
257
258 BASE64Encoder base64 = new BASE64Encoder();
259 MessageDigest md = MessageDigest.getInstance("SHA1");
260 PrintStream print = new PrintStream(
261 new DigestOutputStream(new ByteArrayOutputStream(), md),
262 true, "UTF-8");
263
264 // Digest of the entire manifest
265 manifest.write(print);
266 print.flush();
267 main.putValue("SHA1-Digest-Manifest", base64.encode(md.digest()));
268
269 Map<String, Attributes> entries = manifest.getEntries();
270 for (Map.Entry<String, Attributes> entry : entries.entrySet()) {
271 // Digest of the manifest stanza for this entry.
272 print.print("Name: " + entry.getKey() + "\r\n");
273 for (Map.Entry<Object, Object> att : entry.getValue().entrySet()) {
274 print.print(att.getKey() + ": " + att.getValue() + "\r\n");
275 }
276 print.print("\r\n");
277 print.flush();
278
279 Attributes sfAttr = new Attributes();
280 sfAttr.putValue("SHA1-Digest", base64.encode(md.digest()));
281 sf.getEntries().put(entry.getKey(), sfAttr);
282 }
283
284 sf.write(out);
285 }
286
287 /** Write a .RSA file with a digital signature. */
288 private static void writeSignatureBlock(
289 Signature signature, X509Certificate publicKey, OutputStream out)
290 throws IOException, GeneralSecurityException {
291 SignerInfo signerInfo = new SignerInfo(
292 new X500Name(publicKey.getIssuerX500Principal().getName()),
293 publicKey.getSerialNumber(),
294 AlgorithmId.get("SHA1"),
295 AlgorithmId.get("RSA"),
296 signature.sign());
297
298 PKCS7 pkcs7 = new PKCS7(
299 new AlgorithmId[] { AlgorithmId.get("SHA1") },
300 new ContentInfo(ContentInfo.DATA_OID, null),
301 new X509Certificate[] { publicKey },
302 new SignerInfo[] { signerInfo });
303
304 pkcs7.encodeSignedData(out);
305 }
306
307 /**
308 * Copy all the files in a manifest from input to output. We set
309 * the modification times in the output to a fixed time, so as to
310 * reduce variation in the output file and make incremental OTAs
311 * more efficient.
312 */
313 private static void copyFiles(Manifest manifest,
314 JarFile in, JarOutputStream out, long timestamp) throws IOException {
315 byte[] buffer = new byte[4096];
316 int num;
317
318 Map<String, Attributes> entries = manifest.getEntries();
319 List<String> names = new ArrayList(entries.keySet());
320 Collections.sort(names);
321 for (String name : names) {
322 JarEntry inEntry = in.getJarEntry(name);
323 JarEntry outEntry = null;
324 if (inEntry.getMethod() == JarEntry.STORED) {
325 // Preserve the STORED method of the input entry.
326 outEntry = new JarEntry(inEntry);
327 } else {
328 // Create a new entry so that the compressed len is recomputed.
329 outEntry = new JarEntry(name);
330 }
331 outEntry.setTime(timestamp);
332 out.putNextEntry(outEntry);
333
334 InputStream data = in.getInputStream(inEntry);
335 while ((num = data.read(buffer)) > 0) {
336 out.write(buffer, 0, num);
337 }
338 out.flush();
339 }
340 }
341
342 public static void main(String[] args) {
343 if (args.length != 4) {
344 System.err.println("Usage: signapk " +
345 "publickey.x509[.pem] privatekey.pk8 " +
346 "input.jar output.jar");
347 System.exit(2);
348 }
349
350 JarFile inputJar = null;
351 JarOutputStream outputJar = null;
352
353 try {
354 X509Certificate publicKey = readPublicKey(new File(args[0]));
355
356 // Assume the certificate is valid for at least an hour.
357 long timestamp = publicKey.getNotBefore().getTime() + 3600L * 1000;
358
359 PrivateKey privateKey = readPrivateKey(new File(args[1]));
360 inputJar = new JarFile(new File(args[2]), false); // Don't verify.
361 outputJar = new JarOutputStream(new FileOutputStream(args[3]));
362 outputJar.setLevel(9);
363
364 JarEntry je;
365
366 // MANIFEST.MF
367 Manifest manifest = addDigestsToManifest(inputJar);
368 je = new JarEntry(JarFile.MANIFEST_NAME);
369 je.setTime(timestamp);
370 outputJar.putNextEntry(je);
371 manifest.write(outputJar);
372
373 // CERT.SF
374 Signature signature = Signature.getInstance("SHA1withRSA");
375 signature.initSign(privateKey);
376 je = new JarEntry(CERT_SF_NAME);
377 je.setTime(timestamp);
378 outputJar.putNextEntry(je);
379 writeSignatureFile(manifest,
380 new SignatureOutputStream(outputJar, signature));
381
382 // CERT.RSA
383 je = new JarEntry(CERT_RSA_NAME);
384 je.setTime(timestamp);
385 outputJar.putNextEntry(je);
386 writeSignatureBlock(signature, publicKey, outputJar);
387
388 // Everything else
389 copyFiles(manifest, inputJar, outputJar, timestamp);
390 } catch (Exception e) {
391 e.printStackTrace();
392 System.exit(1);
393 } finally {
394 try {
395 if (inputJar != null) inputJar.close();
396 if (outputJar != null) outputJar.close();
397 } catch (IOException e) {
398 e.printStackTrace();
399 System.exit(1);
400 }
401 }
402 }
403 }
