src/com/saurik/backport/Hook.java

   1 /* Backport - Bring New Fixes to old Androids
   2  * Copyright (C) 2013  Jay Freeman (saurik)
   3 */
   4
   5 /* GNU Lesser General Public License, Version 3 {{{ */
   6 /*
   7  * Substrate is free software: you can redistribute it and/or modify it under
   8  * the terms of the GNU Lesser General Public License as published by the
   9  * Free Software Foundation, either version 3 of the License, or (at your
  10  * option) any later version.
  11  *
  12  * Substrate is distributed in the hope that it will be useful, but WITHOUT
  13  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  14  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public
  15  * License for more details.
  16  *
  17  * You should have received a copy of the GNU Lesser General Public License
  18  * along with Substrate.  If not, see <http://www.gnu.org/licenses/>.
  19 **/
  20 /* }}} */
  21
  22 package com.saurik.backport;
  23
  24 import java.lang.reflect.Constructor;
  25 import java.lang.reflect.Field;
  26 import java.lang.reflect.Method;
  27
  28 import java.io.ByteArrayInputStream;
  29 import java.io.DataInputStream;
  30 import java.io.InputStream;
  31 import java.io.RandomAccessFile;
  32
  33 import java.util.LinkedHashMap;
  34
  35 import java.util.zip.ZipEntry;
  36 import java.util.zip.ZipException;
  37 import java.util.zip.ZipFile;
  38
  39 import android.util.Log;
  40
  41 import com.saurik.substrate.MS;
  42
  43 public class Hook {
  44     private static class WrongException
  45         extends RuntimeException
  46     {
  47         public WrongException(Throwable cause) {
  48             super(cause);
  49         }
  50     }
  51
  52     private static Field scanField(Class clazz, String... names) {
  53         for (String name : names) try {
  54             return clazz.getDeclaredField(name);
  55         } catch (NoSuchFieldException e) {}
  56         return null;
  57     }
  58
  59     private static Method findMethod(Class<?> clazz, String name, Class... args) {
  60         try {
  61             return clazz.getDeclaredMethod(name, args);
  62         } catch (NoSuchMethodException e) {
  63             return null;
  64         }
  65     }
  66
  67     private static Constructor findConstructor(Class<?> clazz, Class... args) {
  68         try {
  69             return clazz.getDeclaredConstructor(args);
  70         } catch (NoSuchMethodException e) {
  71             return null;
  72         }
  73     }
  74
  75     private static void fixZipEntry$init$() {
  76         final Constructor ZipEntry$init$ = findConstructor(ZipEntry.class, byte[].class, InputStream.class);
  77         if (ZipEntry$init$ == null)
  78             return;
  79
  80         MS.hookMethod(ZipEntry.class, ZipEntry$init$,
  81             new MS.MethodAlteration<ZipEntry, Void>() {
  82                 public Void invoked(ZipEntry thiz, Object... args)
  83                     throws Throwable
  84                 {
  85                     byte[] header = (byte[]) args[0];
  86
  87                     invoke(thiz, args);
  88
  89                     DataInputStream in = new DataInputStream(new ByteArrayInputStream(header));
  90
  91                     in.skip(8);
  92                     for (int i = 0; i != 2; ++i)
  93                         if ((in.readShort() & 0x0080) != 0)
  94                             throw new ZipException("bug #99695860 [" + thiz.getName() + "]");
  95
  96                     in.skip(16);
  97                     for (int i = 0; i != 3; ++i)
  98                         if ((in.readShort() & 0x0080) != 0)
  99                             throw new ZipException("bug #99695860 [" + thiz.getName() + "]");
 100
 101                     return null;
 102                 }
 103             }
 104         );
 105     }
 106
 107     private static void fixZipFile$getInputStream() {
 108         final Field ZipFile$mRaf = scanField(ZipFile.class, "mRaf", "raf");
 109         if (ZipFile$mRaf == null)
 110             return;
 111         ZipFile$mRaf.setAccessible(true);
 112
 113         final Field ZipEntry$mLocalHeaderRelOffset = scanField(ZipEntry.class, "mLocalHeaderRelOffset", "localHeaderRelOffset");
 114         if (ZipEntry$mLocalHeaderRelOffset == null)
 115             return;
 116         ZipEntry$mLocalHeaderRelOffset.setAccessible(true);
 117
 118         final Method ZipFile$getInputStream = findMethod(ZipFile.class, "getInputStream", ZipEntry.class);
 119         if (ZipFile$getInputStream == null)
 120             return;
 121
 122         MS.hookMethod(ZipFile.class, ZipFile$getInputStream,
 123             new MS.MethodAlteration<ZipFile, InputStream>() {
 124                 public InputStream invoked(ZipFile thiz, Object... args)
 125                     throws Throwable
 126                 {
 127                     ZipEntry entry = (ZipEntry) args[0];
 128
 129                     RandomAccessFile raf = (RandomAccessFile) ZipFile$mRaf.get(thiz);
 130                     synchronized (raf) {
 131                         raf.seek(ZipEntry$mLocalHeaderRelOffset.getLong(entry));
 132
 133                         raf.skipBytes(6);
 134                         if ((raf.readShort() & 0x0080) != 0)
 135                             throw new ZipException("bug #99695860 [" + thiz.getName() + "]");
 136
 137                         raf.skipBytes(20);
 138                         if ((raf.readShort() & 0x0080) != 0)
 139                             throw new ZipException("bug #99695860 [" + thiz.getName() + "]");
 140                     }
 141
 142                     return invoke(thiz, args);
 143                 }
 144             }
 145         );
 146     }
 147
 148     private static void fixZipFile$readCentralDir() {
 149         final Field ZipFile$entries = scanField(ZipFile.class, "mEntries", "entries");
 150         if (ZipFile$entries == null)
 151             return;
 152         ZipFile$entries.setAccessible(true);
 153
 154         final Method ZipFile$readCentralDir = findMethod(ZipFile.class, "readCentralDir");
 155         if (ZipFile$readCentralDir == null)
 156             return;
 157
 158         MS.hookMethod(ZipFile.class, ZipFile$readCentralDir,
 159             new MS.MethodAlteration<ZipFile, Void>() {
 160                 public Void invoked(ZipFile thiz, Object... args)
 161                     throws Throwable
 162                 {
 163                     ZipFile$entries.set(thiz, new LinkedHashMap<String, ZipEntry>() {
 164                         public ZipEntry put(String key, ZipEntry value) {
 165                             if (super.put(key, value) != null)
 166                                 throw new WrongException(new ZipException("bug #8219321 [" + key + "]"));
 167                             return null;
 168                         }
 169                     });
 170
 171                     try {
 172                         return invoke(thiz, args);
 173                     } catch (WrongException wrong) {
 174                         throw wrong.getCause();
 175                     }
 176                 }
 177             }
 178         );
 179     }
 180
 181     public static void initialize() {
 182         fixZipEntry$init$();
 183         fixZipFile$getInputStream();
 184         fixZipFile$readCentralDir();
 185     }
 186 }