verity/VerityVerifier.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.File;
  20 import java.io.RandomAccessFile;
  21 import java.nio.ByteBuffer;
  22 import java.nio.ByteOrder;
  23 import java.lang.Process;
  24 import java.lang.Runtime;
  25 import java.security.PublicKey;
  26 import java.security.PrivateKey;
  27 import java.security.Security;
  28 import java.security.cert.X509Certificate;
  29 import org.bouncycastle.jce.provider.BouncyCastleProvider;
  30
  31 public class VerityVerifier {
  32
  33     private static final int EXT4_SB_MAGIC = 0xEF53;
  34     private static final int EXT4_SB_OFFSET = 0x400;
  35     private static final int EXT4_SB_OFFSET_MAGIC = EXT4_SB_OFFSET + 0x38;
  36     private static final int EXT4_SB_OFFSET_LOG_BLOCK_SIZE = EXT4_SB_OFFSET + 0x18;
  37     private static final int EXT4_SB_OFFSET_BLOCKS_COUNT_LO = EXT4_SB_OFFSET + 0x4;
  38     private static final int EXT4_SB_OFFSET_BLOCKS_COUNT_HI = EXT4_SB_OFFSET + 0x150;
  39     private static final int VERITY_MAGIC = 0xB001B001;
  40     private static final int VERITY_SIGNATURE_SIZE = 256;
  41     private static final int VERITY_VERSION = 0;
  42
  43     /**
  44      * Converts a 4-byte little endian value to a Java integer
  45      * @param value Little endian integer to convert
  46      */
  47      public static int fromle(int value) {
  48         byte[] bytes = ByteBuffer.allocate(4).putInt(value).array();
  49         return ByteBuffer.wrap(bytes).order(ByteOrder.LITTLE_ENDIAN).getInt();
  50     }
  51
  52      /**
  53      * Converts a 2-byte little endian value to Java a integer
  54      * @param value Little endian short to convert
  55      */
  56      public static int fromle(short value) {
  57         return fromle(value << 16);
  58     }
  59
  60     /**
  61      * Unsparses a sparse image into a temporary file and returns a
  62      * handle to the file
  63      * @param fname Path to a sparse image file
  64      */
  65      public static RandomAccessFile openImage(String fname) throws Exception {
  66         File tmp = File.createTempFile("system", ".raw");
  67         tmp.deleteOnExit();
  68
  69         Process p = Runtime.getRuntime().exec("simg2img " + fname +
  70                             " " + tmp.getAbsoluteFile());
  71
  72         p.waitFor();
  73         if (p.exitValue() != 0) {
  74             throw new IllegalArgumentException("Invalid image: failed to unsparse");
  75         }
  76
  77         return new RandomAccessFile(tmp, "r");
  78     }
  79
  80     /**
  81      * Reads the ext4 superblock and calculates the size of the system image,
  82      * after which we should find the verity metadata
  83      * @param img File handle to the image file
  84      */
  85     public static long getMetadataPosition(RandomAccessFile img)
  86             throws Exception {
  87         img.seek(EXT4_SB_OFFSET_MAGIC);
  88         int magic = fromle(img.readShort());
  89
  90         if (magic != EXT4_SB_MAGIC) {
  91             throw new IllegalArgumentException("Invalid image: not a valid ext4 image");
  92         }
  93
  94         img.seek(EXT4_SB_OFFSET_BLOCKS_COUNT_LO);
  95         long blocksCountLo = fromle(img.readInt());
  96
  97         img.seek(EXT4_SB_OFFSET_LOG_BLOCK_SIZE);
  98         long logBlockSize = fromle(img.readInt());
  99
 100         img.seek(EXT4_SB_OFFSET_BLOCKS_COUNT_HI);
 101         long blocksCountHi = fromle(img.readInt());
 102
 103         long blockSizeBytes = 1L << (10 + logBlockSize);
 104         long blockCount = (blocksCountHi << 32) + blocksCountLo;
 105         return blockSizeBytes * blockCount;
 106     }
 107
 108     /**
 109      * Reads and validates verity metadata, and check the signature against the
 110      * given public key
 111      * @param img File handle to the image file
 112      * @param key Public key to use for signature verification
 113      */
 114     public static boolean verifyMetaData(RandomAccessFile img, PublicKey key)
 115             throws Exception {
 116         img.seek(getMetadataPosition(img));
 117         int magic = fromle(img.readInt());
 118
 119         if (magic != VERITY_MAGIC) {
 120             throw new IllegalArgumentException("Invalid image: verity metadata not found");
 121         }
 122
 123         int version = fromle(img.readInt());
 124
 125         if (version != VERITY_VERSION) {
 126             throw new IllegalArgumentException("Invalid image: unknown metadata version");
 127         }
 128
 129         byte[] signature = new byte[VERITY_SIGNATURE_SIZE];
 130         img.readFully(signature);
 131
 132         int tableSize = fromle(img.readInt());
 133
 134         byte[] table = new byte[tableSize];
 135         img.readFully(table);
 136
 137         return Utils.verify(key, table, signature,
 138                    Utils.getSignatureAlgorithmIdentifier(key));
 139     }
 140
 141     public static void main(String[] args) throws Exception {
 142         if (args.length != 2) {
 143             System.err.println("Usage: VerityVerifier <sparse.img> <certificate.x509.pem>");
 144             System.exit(1);
 145         }
 146
 147         Security.addProvider(new BouncyCastleProvider());
 148
 149         X509Certificate cert = Utils.loadPEMCertificate(args[1]);
 150         PublicKey key = cert.getPublicKey();
 151         RandomAccessFile img = openImage(args[0]);
 152
 153         try {
 154             if (verifyMetaData(img, key)) {
 155                 System.err.println("Signature is VALID");
 156                 System.exit(0);
 157             } else {
 158                 System.err.println("Signature is INVALID");
 159             }
 160         } catch (Exception e) {
 161             e.printStackTrace(System.err);
 162         }
 163
 164         System.exit(1);
 165     }
 166 }