verity/BootSignature.java

   1 /*
   2  * Copyright (C) 2014 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.verity;
  18
  19 import java.io.ByteArrayInputStream;
  20 import java.io.IOException;
  21 import java.nio.ByteBuffer;
  22 import java.nio.ByteOrder;
  23 import java.security.PrivateKey;
  24 import java.security.PublicKey;
  25 import java.security.Security;
  26 import java.security.cert.X509Certificate;
  27 import java.security.cert.Certificate;
  28 import java.security.cert.CertificateFactory;
  29 import java.security.cert.CertificateEncodingException;
  30 import java.util.Arrays;
  31 import org.bouncycastle.asn1.ASN1Encodable;
  32 import org.bouncycastle.asn1.ASN1EncodableVector;
  33 import org.bouncycastle.asn1.ASN1Integer;
  34 import org.bouncycastle.asn1.ASN1Object;
  35 import org.bouncycastle.asn1.ASN1ObjectIdentifier;
  36 import org.bouncycastle.asn1.ASN1OctetString;
  37 import org.bouncycastle.asn1.ASN1Primitive;
  38 import org.bouncycastle.asn1.ASN1Sequence;
  39 import org.bouncycastle.asn1.ASN1InputStream;
  40 import org.bouncycastle.asn1.DEROctetString;
  41 import org.bouncycastle.asn1.DERPrintableString;
  42 import org.bouncycastle.asn1.DERSequence;
  43 import org.bouncycastle.asn1.util.ASN1Dump;
  44 import org.bouncycastle.asn1.x509.AlgorithmIdentifier;
  45 import org.bouncycastle.jce.provider.BouncyCastleProvider;
  46
  47 /**
  48  *    AndroidVerifiedBootSignature DEFINITIONS ::=
  49  *    BEGIN
  50  *        formatVersion ::= INTEGER
  51  *        certificate ::= Certificate
  52  *        algorithmIdentifier ::= SEQUENCE {
  53  *            algorithm OBJECT IDENTIFIER,
  54  *            parameters ANY DEFINED BY algorithm OPTIONAL
  55  *        }
  56  *        authenticatedAttributes ::= SEQUENCE {
  57  *            target CHARACTER STRING,
  58  *            length INTEGER
  59  *        }
  60  *        signature ::= OCTET STRING
  61  *     END
  62  */
  63
  64 public class BootSignature extends ASN1Object
  65 {
  66     private ASN1Integer             formatVersion;
  67     private ASN1Encodable           certificate;
  68     private AlgorithmIdentifier     algorithmIdentifier;
  69     private DERPrintableString      target;
  70     private ASN1Integer             length;
  71     private DEROctetString          signature;
  72     private PublicKey               publicKey;
  73
  74     private static final int FORMAT_VERSION = 1;
  75
  76     /**
  77      * Initializes the object for signing an image file
  78      * @param target Target name, included in the signed data
  79      * @param length Length of the image, included in the signed data
  80      */
  81     public BootSignature(String target, int length) {
  82         this.formatVersion = new ASN1Integer(FORMAT_VERSION);
  83         this.target = new DERPrintableString(target);
  84         this.length = new ASN1Integer(length);
  85     }
  86
  87     /**
  88      * Initializes the object for verifying a signed image file
  89      * @param signature Signature footer
  90      */
  91     public BootSignature(byte[] signature)
  92             throws Exception {
  93         ASN1InputStream stream = new ASN1InputStream(signature);
  94         ASN1Sequence sequence = (ASN1Sequence) stream.readObject();
  95
  96         formatVersion = (ASN1Integer) sequence.getObjectAt(0);
  97         if (formatVersion.getValue().intValue() != FORMAT_VERSION) {
  98             throw new IllegalArgumentException("Unsupported format version");
  99         }
 100
 101         certificate = sequence.getObjectAt(1);
 102         byte[] encoded = ((ASN1Object) certificate).getEncoded();
 103         ByteArrayInputStream bis = new ByteArrayInputStream(encoded);
 104
 105         CertificateFactory cf = CertificateFactory.getInstance("X.509");
 106         X509Certificate c = (X509Certificate) cf.generateCertificate(bis);
 107         publicKey = c.getPublicKey();
 108
 109         ASN1Sequence algId = (ASN1Sequence) sequence.getObjectAt(2);
 110         algorithmIdentifier = new AlgorithmIdentifier(
 111             (ASN1ObjectIdentifier) algId.getObjectAt(0));
 112
 113         ASN1Sequence attrs = (ASN1Sequence) sequence.getObjectAt(3);
 114         target = (DERPrintableString) attrs.getObjectAt(0);
 115         length = (ASN1Integer) attrs.getObjectAt(1);
 116
 117         this.signature = (DEROctetString) sequence.getObjectAt(4);
 118     }
 119
 120     public ASN1Object getAuthenticatedAttributes() {
 121         ASN1EncodableVector attrs = new ASN1EncodableVector();
 122         attrs.add(target);
 123         attrs.add(length);
 124         return new DERSequence(attrs);
 125     }
 126
 127     public byte[] getEncodedAuthenticatedAttributes() throws IOException {
 128         return getAuthenticatedAttributes().getEncoded();
 129     }
 130
 131     public AlgorithmIdentifier getAlgorithmIdentifier() {
 132         return algorithmIdentifier;
 133     }
 134
 135     public PublicKey getPublicKey() {
 136         return publicKey;
 137     }
 138
 139     public byte[] getSignature() {
 140         return signature.getOctets();
 141     }
 142
 143     public void setSignature(byte[] sig, AlgorithmIdentifier algId) {
 144         algorithmIdentifier = algId;
 145         signature = new DEROctetString(sig);
 146     }
 147
 148     public void setCertificate(X509Certificate cert)
 149             throws Exception, IOException, CertificateEncodingException {
 150         ASN1InputStream s = new ASN1InputStream(cert.getEncoded());
 151         certificate = s.readObject();
 152         publicKey = cert.getPublicKey();
 153     }
 154
 155     public byte[] generateSignableImage(byte[] image) throws IOException {
 156         byte[] attrs = getEncodedAuthenticatedAttributes();
 157         byte[] signable = Arrays.copyOf(image, image.length + attrs.length);
 158         for (int i=0; i < attrs.length; i++) {
 159             signable[i+image.length] = attrs[i];
 160         }
 161         return signable;
 162     }
 163
 164     public byte[] sign(byte[] image, PrivateKey key) throws Exception {
 165         byte[] signable = generateSignableImage(image);
 166         return Utils.sign(key, signable);
 167     }
 168
 169     public boolean verify(byte[] image) throws Exception {
 170         if (length.getValue().intValue() != image.length) {
 171             throw new IllegalArgumentException("Invalid image length");
 172         }
 173
 174         byte[] signable = generateSignableImage(image);
 175         return Utils.verify(publicKey, signable, signature.getOctets(),
 176                     algorithmIdentifier);
 177     }
 178
 179     public ASN1Primitive toASN1Primitive() {
 180         ASN1EncodableVector v = new ASN1EncodableVector();
 181         v.add(formatVersion);
 182         v.add(certificate);
 183         v.add(algorithmIdentifier);
 184         v.add(getAuthenticatedAttributes());
 185         v.add(signature);
 186         return new DERSequence(v);
 187     }
 188
 189     public static int getSignableImageSize(byte[] data) throws Exception {
 190         if (!Arrays.equals(Arrays.copyOfRange(data, 0, 8),
 191                 "ANDROID!".getBytes("US-ASCII"))) {
 192             throw new IllegalArgumentException("Invalid image header: missing magic");
 193         }
 194
 195         ByteBuffer image = ByteBuffer.wrap(data);
 196         image.order(ByteOrder.LITTLE_ENDIAN);
 197
 198         image.getLong(); // magic
 199         int kernelSize = image.getInt();
 200         image.getInt(); // kernel_addr
 201         int ramdskSize = image.getInt();
 202         image.getInt(); // ramdisk_addr
 203         int secondSize = image.getInt();
 204         image.getLong(); // second_addr + tags_addr
 205         int pageSize = image.getInt();
 206
 207         int length = pageSize // include the page aligned image header
 208                 + ((kernelSize + pageSize - 1) / pageSize) * pageSize
 209                 + ((ramdskSize + pageSize - 1) / pageSize) * pageSize
 210                 + ((secondSize + pageSize - 1) / pageSize) * pageSize;
 211
 212         length = ((length + pageSize - 1) / pageSize) * pageSize;
 213
 214         if (length <= 0) {
 215             throw new IllegalArgumentException("Invalid image header: invalid length");
 216         }
 217
 218         return length;
 219     }
 220
 221     public static void doSignature( String target,
 222                                     String imagePath,
 223                                     String keyPath,
 224                                     String certPath,
 225                                     String outPath) throws Exception {
 226
 227         byte[] image = Utils.read(imagePath);
 228         int signableSize = getSignableImageSize(image);
 229
 230         if (signableSize < image.length) {
 231             System.err.println("NOTE: truncating file " + imagePath +
 232                     " from " + image.length + " to " + signableSize + " bytes");
 233             image = Arrays.copyOf(image, signableSize);
 234         } else if (signableSize > image.length) {
 235             throw new IllegalArgumentException("Invalid image: too short, expected " +
 236                     signableSize + " bytes");
 237         }
 238
 239         BootSignature bootsig = new BootSignature(target, image.length);
 240
 241         X509Certificate cert = Utils.loadPEMCertificate(certPath);
 242         bootsig.setCertificate(cert);
 243
 244         PrivateKey key = Utils.loadDERPrivateKeyFromFile(keyPath);
 245         bootsig.setSignature(bootsig.sign(image, key),
 246             Utils.getSignatureAlgorithmIdentifier(key));
 247
 248         byte[] encoded_bootsig = bootsig.getEncoded();
 249         byte[] image_with_metadata = Arrays.copyOf(image, image.length + encoded_bootsig.length);
 250
 251         System.arraycopy(encoded_bootsig, 0, image_with_metadata,
 252                 image.length, encoded_bootsig.length);
 253
 254         Utils.write(image_with_metadata, outPath);
 255     }
 256
 257     public static void verifySignature(String imagePath, String certPath) throws Exception {
 258         byte[] image = Utils.read(imagePath);
 259         int signableSize = getSignableImageSize(image);
 260
 261         if (signableSize >= image.length) {
 262             throw new IllegalArgumentException("Invalid image: not signed");
 263         }
 264
 265         byte[] signature = Arrays.copyOfRange(image, signableSize, image.length);
 266         BootSignature bootsig = new BootSignature(signature);
 267
 268         if (!certPath.isEmpty()) {
 269             System.err.println("NOTE: verifying using public key from " + certPath);
 270             bootsig.setCertificate(Utils.loadPEMCertificate(certPath));
 271         }
 272
 273         try {
 274             if (bootsig.verify(Arrays.copyOf(image, signableSize))) {
 275                 System.err.println("Signature is VALID");
 276                 System.exit(0);
 277             } else {
 278                 System.err.println("Signature is INVALID");
 279             }
 280         } catch (Exception e) {
 281             e.printStackTrace(System.err);
 282         }
 283         System.exit(1);
 284     }
 285
 286     /* Example usage for signing a boot image using dev keys:
 287         java -cp \
 288             ../../../out/host/common/obj/JAVA_LIBRARIES/BootSignature_intermediates/ \
 289                 classes/com.android.verity.BootSignature \
 290             /boot \
 291             ../../../out/target/product/$PRODUCT/boot.img \
 292             ../../../build/target/product/security/verity.pk8 \
 293             ../../../build/target/product/security/verity.x509.pem \
 294             /tmp/boot.img.signed
 295     */
 296     public static void main(String[] args) throws Exception {
 297         Security.addProvider(new BouncyCastleProvider());
 298
 299         if ("-verify".equals(args[0])) {
 300             String certPath = "";
 301
 302             if (args.length >= 4 && "-certificate".equals(args[2])) {
 303                 /* args[3] is the path to a public key certificate */
 304                 certPath = args[3];
 305             }
 306
 307             /* args[1] is the path to a signed boot image */
 308             verifySignature(args[1], certPath);
 309         } else {
 310             /* args[0] is the target name, typically /boot
 311                args[1] is the path to a boot image to sign
 312                args[2] is the path to a private key
 313                args[3] is the path to the matching public key certificate
 314                args[4] is the path where to output the signed boot image
 315             */
 316             doSignature(args[0], args[1], args[2], args[3], args[4]);
 317         }
 318     }
 319 }