+ *
The extra data is expected to follow the recommendation of + * the .ZIP File Format Specification created by PKWARE Inc. :
+ *+ *
Any extra data that cannot be parsed by the rules above will be + * consumed as "unparseable" extra data and treated differently by the + * methods of this class. Versions prior to Apache Commons Compress + * 1.1 would have thrown an exception if any attempt was made to read + * or write extra data not conforming to the recommendation.
+ * + * @see + * .ZIP File Format Specification + */ +public class ZipEntry extends java.util.zip.ZipEntry implements Cloneable { + + public static final int PLATFORM_UNIX = 3; + public static final int PLATFORM_FAT = 0; + private static final int SHORT_MASK = 0xFFFF; + private static final int SHORT_SHIFT = 16; + + private int internalAttributes = 0; + private int platform = PLATFORM_FAT; + private long externalAttributes = 0; + private LinkedHashMapint value
+ * @since 1.1
+ */
+ public void setInternalAttributes(int value) {
+ internalAttributes = value;
+ }
+
+ /**
+ * Retrieves the external file attributes.
+ *
+ * @return the external file attributes
+ * @since 1.1
+ */
+ public long getExternalAttributes() {
+ return externalAttributes;
+ }
+
+ /**
+ * Sets the external file attributes.
+ *
+ * @param value an long value
+ * @since 1.1
+ */
+ public void setExternalAttributes(long value) {
+ externalAttributes = value;
+ }
+
+ /**
+ * Sets Unix permissions in a way that is understood by Info-Zip's
+ * unzip command.
+ *
+ * @param mode an int value
+ * @since Ant 1.5.2
+ */
+ @SuppressWarnings("OctalInteger")
+ public void setUnixMode(int mode) {
+ // CheckStyle:MagicNumberCheck OFF - no point
+ setExternalAttributes((mode << SHORT_SHIFT)
+ // MS-DOS read-only attribute
+ | ((mode & 0200) == 0 ? 1 : 0)
+ // MS-DOS directory flag
+ | (isDirectory() ? 0x10 : 0));
+ // CheckStyle:MagicNumberCheck ON
+ platform = PLATFORM_UNIX;
+ }
+
+ /**
+ * Unix permission.
+ *
+ * @return the unix permissions
+ * @since Ant 1.6
+ */
+ public int getUnixMode() {
+ return platform != PLATFORM_UNIX ? 0 :
+ (int) ((getExternalAttributes() >> SHORT_SHIFT) & SHORT_MASK);
+ }
+
+ /**
+ * Platform specification to put into the "version made
+ * by" part of the central file header.
+ *
+ * @return PLATFORM_FAT unless {@link #setUnixMode setUnixMode}
+ * has been called, in which case PLATORM_UNIX will be returned.
+ * @since Ant 1.5.2
+ */
+ public int getPlatform() {
+ return platform;
+ }
+
+ /**
+ * Set the platform (UNIX or FAT).
+ *
+ * @param platform an int value - 0 is FAT, 3 is UNIX
+ * @since 1.9
+ */
+ protected void setPlatform(int platform) {
+ this.platform = platform;
+ }
+
+ /**
+ * Replaces all currently attached extra fields with the new array.
+ *
+ * @param fields an array of extra fields
+ * @since 1.1
+ */
+ public void setExtraFields(ZipExtraField[] fields) {
+ extraFields = new LinkedHashMap<>();
+ for (ZipExtraField field : fields) {
+ if (field instanceof UnparseableExtraFieldData) {
+ unparseableExtra = (UnparseableExtraFieldData) field;
+ } else {
+ extraFields.put(field.getHeaderId(), field);
+ }
+ }
+ setExtra();
+ }
+
+ /**
+ * Retrieves all extra fields that have been parsed successfully.
+ *
+ * @return an array of the extra fields
+ */
+ public ZipExtraField[] getExtraFields() {
+ return getExtraFields(false);
+ }
+
+ /**
+ * Retrieves extra fields.
+ *
+ * @param includeUnparseable whether to also return unparseable
+ * extra fields as {@link UnparseableExtraFieldData} if such data
+ * exists.
+ * @return an array of the extra fields
+ * @since 1.1
+ */
+ public ZipExtraField[] getExtraFields(boolean includeUnparseable) {
+ if (extraFields == null) {
+ return !includeUnparseable || unparseableExtra == null
+ ? new ZipExtraField[0]
+ : new ZipExtraField[]{unparseableExtra};
+ }
+ List+ *
If no extra field of the same type exists, the field will be + * added as last field.
+ * + * @param ze an extra field + * @since 1.1 + */ + public void addExtraField(ZipExtraField ze) { + if (ze instanceof UnparseableExtraFieldData) { + unparseableExtra = (UnparseableExtraFieldData) ze; + } else { + if (extraFields == null) { + extraFields = new LinkedHashMap<>(); + } + extraFields.put(ze.getHeaderId(), ze); + } + setExtra(); + } + + /** + * Adds an extra field - replacing an already present extra field + * of the same type. + *+ *
The new extra field will be the first one.
+ * + * @param ze an extra field + * @since 1.1 + */ + public void addAsFirstExtraField(ZipExtraField ze) { + if (ze instanceof UnparseableExtraFieldData) { + unparseableExtra = (UnparseableExtraFieldData) ze; + } else { + LinkedHashMap+ *
This either stores the size for later usage or invokes + * setCompressedSize via reflection.
+ * + * @param size the size to use + * @since 1.2 + * Use setCompressedSize directly. + */ + public void setComprSize(long size) { + setCompressedSize(size); + } + + /** + * Get the name of the entry. + * + * @return the entry name + * @since 1.9 + */ + public String getName() { + return name == null ? super.getName() : name; + } + + public String getParent() { + return parent; + } + + public String getSimpleName() { + return simpleName; + } + + /** + * Is this entry a directory? + * + * @return true if the entry is a directory + * @since 1.10 + */ + public boolean isDirectory() { + return getName().endsWith("/"); + } + + /** + * Set the name of the entry. + * + * @param name the name to use + */ + public void setName(String name) { + if (name != null && getPlatform() == PLATFORM_FAT + && !name.contains("/")) { + name = name.replace('\\', '/'); + } + this.name = name; + setParentAndSimpleName(); + } + + private void setParentAndSimpleName() { + if (name == null || name.length() == 0) + return; + if (name.charAt(name.length() - 1) == '/') { + int index = name.lastIndexOf('/', name.length() - 2); + if (index == -1) { + simpleName = name.substring(0, name.length() - 1); + parent = null; + } else { + simpleName = name.substring(index + 1, name.length() - 1); + parent = name.substring(0, index + 1); + } + } else { + int index = name.lastIndexOf('/'); + if (index == -1) { + simpleName = name; + parent = null; + } else { + simpleName = name.substring(index + 1); + parent = name.substring(0, index + 1); + } + } + } + + private int hash = 0; + /** + * Get the hashCode of the entry. + * This uses the name as the hashcode. + * + * @return a hashcode. + * @since Ant 1.7 + */ + public int hashCode() { + // this method has severe consequences on performance. We cannot rely + // on the super.hashCode() method since super.getName() always return + // the empty string in the current implemention (there's no setter) + // so it is basically draining the performance of a hashmap lookup + int h = hash; + if (h == 0) { + h = getName().hashCode(); + hash = h; + } + return h; + } + + /** + * The equality method. In this case, the implementation returns 'this == o' + * which is basically the equals method of the Object class. + * + * @param obj the object to compare to + * @return true if this object is the same aso
+ * @since Ant 1.7
+ */
+ public boolean equals(Object obj) {
+ return this == obj;
+ }
+
+ /**
+ * If there are no extra fields, use the given fields as new extra
+ * data - otherwise merge the fields assuming the existing fields
+ * and the new fields stem from different locations inside the
+ * archive.
+ *
+ * @param f the extra fields to merge
+ * @param local whether the new fields originate from local data
+ */
+ private void mergeExtraFields(ZipExtraField[] f, boolean local)
+ throws ZipException {
+ if (extraFields == null) {
+ setExtraFields(f);
+ } else {
+ for (ZipExtraField aF : f) {
+ ZipExtraField existing;
+ if (aF instanceof UnparseableExtraFieldData) {
+ existing = unparseableExtra;
+ } else {
+ existing = getExtraField(aF.getHeaderId());
+ }
+ if (existing == null) {
+ addExtraField(aF);
+ } else {
+ if (local
+ || !(existing
+ instanceof CentralDirectoryParsingZipExtraField)) {
+ byte[] b = aF.getLocalFileDataData();
+ existing.parseFromLocalFileData(b, 0, b.length);
+ } else {
+ byte[] b = aF.getCentralDirectoryData();
+ ((CentralDirectoryParsingZipExtraField) existing)
+ .parseFromCentralDirectoryData(b, 0, b.length);
+ }
+ }
+ }
+ setExtra();
+ }
+ }
+}
diff --git a/plugin/src/main/java/top/niunaijun/blackobfuscator/core/utils/zip/ZipFile.java b/plugin/src/main/java/top/niunaijun/blackobfuscator/core/utils/zip/ZipFile.java
new file mode 100644
index 0000000..f588077
--- /dev/null
+++ b/plugin/src/main/java/top/niunaijun/blackobfuscator/core/utils/zip/ZipFile.java
@@ -0,0 +1,747 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+package top.niunaijun.blackobfuscator.core.utils.zip;
+
+
+import top.niunaijun.blackobfuscator.core.utils.zip.encoding.ZipEncoding;
+import top.niunaijun.blackobfuscator.core.utils.zip.encoding.ZipEncodingHelper;
+import top.niunaijun.blackobfuscator.core.utils.zip.extrafield.AbstractUnicodeExtraField;
+import top.niunaijun.blackobfuscator.core.utils.zip.extrafield.UnicodeCommentExtraField;
+import top.niunaijun.blackobfuscator.core.utils.zip.extrafield.UnicodePathExtraField;
+
+import java.io.Closeable;
+import java.io.File;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.RandomAccessFile;
+import java.util.Calendar;
+import java.util.Collections;
+import java.util.Date;
+import java.util.Enumeration;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.Map;
+import java.util.zip.CRC32;
+import java.util.zip.Inflater;
+import java.util.zip.InflaterInputStream;
+import java.util.zip.ZipException;
+
+/**
+ * Replacement for java.util.ZipFile.
+ * + *
This class adds support for file name encodings other than UTF-8
+ * (which is required to work on ZIP files created by native zip tools
+ * and is able to skip a preamble like the one found in self
+ * extracting archives. Furthermore it returns instances of
+ * org.apache.tools.zip.ZipEntry instead of
+ * java.util.zip.ZipEntry.
+ *
It doesn't extend java.util.zip.ZipFile as it would
+ * have to reimplement all methods anyway. Like
+ * java.util.ZipFile, it uses RandomAccessFile under the
+ * covers and supports compressed and uncompressed entries.
+ *
The method signatures mimic the ones of
+ * java.util.zip.ZipFile, with a couple of exceptions:
+ *
+ *
org.apache.tools.zip.ZipEntry instances.null if no entry by
+ * that name exists.
+ *
+ * @param name name of the entry.
+ * @return the ZipEntry corresponding to the given name - or
+ * null if not present.
+ */
+ public ZipEntry getEntry(String name) {
+ return nameMap.get(name);
+ }
+
+ /**
+ * Returns an InputStream for reading the contents of the given entry.
+ *
+ * @param ze the entry to get the stream for.
+ * @return a stream to read the entry from.
+ * @throws IOException if unable to getInstance an input stream from the zipenty
+ * @throws ZipException if the zipentry has an unsupported
+ * compression method
+ */
+ public InputStream getInputStream(ZipEntry ze)
+ throws IOException {
+ OffsetEntry offsetEntry = entries.get(ze);
+ if (offsetEntry == null) {
+ return null;
+ }
+ long start = offsetEntry.dataOffset;
+ BoundedInputStream bis =
+ new BoundedInputStream(start, ze.getCompressedSize());
+ switch (ze.getMethod()) {
+ case ZipEntry.STORED:
+ return bis;
+ case ZipEntry.DEFLATED:
+ bis.addDummy();
+ final Inflater inflater = new Inflater(true);
+ return new InflaterInputStream(bis, inflater) {
+ public void close() throws IOException {
+ super.close();
+ inflater.end();
+ }
+ };
+ default:
+ throw new ZipException("Found unsupported compression method "
+ + ze.getMethod());
+ }
+ }
+
+ public InputStream getRawInputStream(ZipEntry ze)
+ throws IOException {
+ OffsetEntry offsetEntry = entries.get(ze);
+ if (offsetEntry == null)
+ return null;
+ return new BoundedInputStream(offsetEntry.dataOffset, ze.getCompressedSize());
+ }
+
+ private static final int CFH_LEN =
+ /* version made by */ SHORT
+ /* version needed to extract */ + SHORT
+ /* general purpose bit flag */ + SHORT
+ /* compression method */ + SHORT
+ /* last mod file time */ + SHORT
+ /* last mod file date */ + SHORT
+ /* crc-32 */ + WORD
+ /* compressed size */ + WORD
+ /* uncompressed size */ + WORD
+ /* filename length */ + SHORT
+ /* extra field length */ + SHORT
+ /* file comment length */ + SHORT
+ /* disk number start */ + SHORT
+ /* internal file attributes */ + SHORT
+ /* external file attributes */ + WORD
+ /* relative offset of local header */ + WORD;
+
+ /**
+ * Reads the central directory of the given archive and populates
+ * the internal tables with ZipEntry instances.
+ * + *
The ZipEntrys will know all data that can be obtained from + * the central directory alone, but not the data that requires the + * local file header or additional data to be read.
+ * + * @return a Map<ZipEntry, NameAndComment>> of + * zipentries that didn't have the language encoding flag set when + * read. + */ + private Map+ *
Also records the offsets for the data to read from the + * entries.
+ */ + private void resolveLocalFileHeaderData(Map+ *
If the field is null or the CRCs don't match, return null + * instead.
+ */ + private String getUnicodeStringIfOriginalMatches(AbstractUnicodeExtraField f, + byte[] orig) { + if (f != null) { + CRC32 crc32 = new CRC32(); + crc32.update(orig); + long origCRC32 = crc32.getValue(); + + if (origCRC32 == f.getNameCRC32()) { + try { + return ZipEncodingHelper + .UTF8_ZIP_ENCODING.decode(f.getUnicodeName()); + } catch (IOException ex) { + // UTF-8 unsupported? should be impossible the + // Unicode*ExtraField must contain some bad bytes + + // TODO log this anywhere? + return null; + } + } + } + return null; + } + + /** + * InputStream that delegates requests to the underlying + * RandomAccessFile, making sure that only bytes from a certain + * range can be read. + */ + private class BoundedInputStream extends InputStream { + private long remaining; + private long loc; + private boolean addDummyByte = false; + + BoundedInputStream(long start, long remaining) { + this.remaining = remaining; + loc = start; + } + + public int read() throws IOException { + if (remaining-- <= 0) { + if (addDummyByte) { + addDummyByte = false; + return 0; + } + return -1; + } + synchronized (archive) { + archive.seek(loc++); + return archive.read(); + } + } + + public int read(byte[] b, int off, int len) throws IOException { + if (remaining <= 0) { + if (addDummyByte) { + addDummyByte = false; + b[off] = 0; + return 1; + } + return -1; + } + + if (len <= 0) { + return 0; + } + + if (len > remaining) { + len = (int) remaining; + } + int ret; + synchronized (archive) { + archive.seek(loc); + ret = archive.read(b, off, len); + } + if (ret > 0) { + loc += ret; + remaining -= ret; + } + return ret; + } + + /** + * Inflater needs an extra dummy byte for nowrap - see + * Inflater's javadocs. + */ + void addDummy() { + addDummyByte = true; + } + } + + private static final class NameAndComment { + private final byte[] name; + private final byte[] comment; + + private NameAndComment(byte[] name, byte[] comment) { + this.name = name; + this.comment = comment; + } + } +} diff --git a/plugin/src/main/java/top/niunaijun/blackobfuscator/core/utils/zip/ZipItem.java b/plugin/src/main/java/top/niunaijun/blackobfuscator/core/utils/zip/ZipItem.java new file mode 100644 index 0000000..b51bd9e --- /dev/null +++ b/plugin/src/main/java/top/niunaijun/blackobfuscator/core/utils/zip/ZipItem.java @@ -0,0 +1,40 @@ +package top.niunaijun.blackobfuscator.core.utils.zip; + +import java.io.InputStream; + +/** + * Created by sunwanquan on 2019/6/18. + * * ∧＿∧ + * (`･ω･∥ + * 丶 つ０ + * しーＪ + * 此处无Bug + */ +public class ZipItem { + private InputStream stream; + private String zipEntryName; + + public ZipItem() { + } + + public ZipItem(InputStream stream, String zipEntryName) { + this.stream = stream; + this.zipEntryName = zipEntryName; + } + + public InputStream getStream() { + return stream; + } + + public void setStream(InputStream stream) { + this.stream = stream; + } + + public String getZipEntryName() { + return zipEntryName; + } + + public void setZipEntryName(String zipEntryName) { + this.zipEntryName = zipEntryName; + } +} diff --git a/plugin/src/main/java/top/niunaijun/blackobfuscator/core/utils/zip/ZipLong.java b/plugin/src/main/java/top/niunaijun/blackobfuscator/core/utils/zip/ZipLong.java new file mode 100644 index 0000000..762c1e7 --- /dev/null +++ b/plugin/src/main/java/top/niunaijun/blackobfuscator/core/utils/zip/ZipLong.java @@ -0,0 +1,186 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + */ + +package top.niunaijun.blackobfuscator.core.utils.zip; + +/** + * Utility class that represents a four byte integer with conversion + * rules for the big endian byte order of ZIP files. + */ +public final class ZipLong implements Cloneable { + + private static final int WORD = 4; + private static final int BYTE_MASK = 0xFF; + + private static final int BYTE_1 = 1; + private static final int BYTE_1_MASK = 0xFF00; + private static final int BYTE_1_SHIFT = 8; + + private static final int BYTE_2 = 2; + private static final int BYTE_2_MASK = 0xFF0000; + private static final int BYTE_2_SHIFT = 16; + + private static final int BYTE_3 = 3; + private static final long BYTE_3_MASK = 0xFF000000L; + private static final int BYTE_3_SHIFT = 24; + + private long value; + + /** + * Create instance from a number. + * + * @param value the long to store as a ZipLong + * @since 1.1 + */ + public ZipLong(long value) { + this.value = value; + } + + /** + * Create instance from bytes. + * + * @param bytes the bytes to store as a ZipLong + * @since 1.1 + */ + public ZipLong(byte[] bytes) { + this(bytes, 0); + } + + /** + * Create instance from the four bytes starting at offset. + * + * @param bytes the bytes to store as a ZipLong + * @param offset the offset to start + * @since 1.1 + */ + public ZipLong(byte[] bytes, int offset) { + value = ZipLong.getValue(bytes, offset); + } + + /** + * Get value as four bytes in big endian byte order. + * + * @return value as four bytes in big endian order + * @since 1.1 + */ + public byte[] getBytes() { + return ZipLong.getBytes(value); + } + + /** + * Get value as Java long. + * + * @return value as a long + * @since 1.1 + */ + public long getValue() { + return value; + } + + /** + * put the value as four bytes in big endian byte order. + * + * @param value the Java long to convert to bytes + * @param buf the output buffer + * @param offset The offset within the output buffer of the first byte to be written. + * must be non-negative and no larger than buf.length-4 + */ + public static void putLong(long value, byte[] buf, int offset) { + buf[offset++] = (byte) ((value & BYTE_MASK)); + buf[offset++] = (byte) ((value & BYTE_1_MASK) >> BYTE_1_SHIFT); + buf[offset++] = (byte) ((value & BYTE_2_MASK) >> BYTE_2_SHIFT); + buf[offset] = (byte) ((value & BYTE_3_MASK) >> BYTE_3_SHIFT); + } + + public void putLong(byte[] buf, int offset) { + putLong(value, buf, offset); + } + + /** + * Get value as four bytes in big endian byte order. + * + * @param value the value to convert + * @return value as four bytes in big endian byte order + */ + public static byte[] getBytes(long value) { + byte[] result = new byte[WORD]; + result[0] = (byte) ((value & BYTE_MASK)); + result[BYTE_1] = (byte) ((value & BYTE_1_MASK) >> BYTE_1_SHIFT); + result[BYTE_2] = (byte) ((value & BYTE_2_MASK) >> BYTE_2_SHIFT); + result[BYTE_3] = (byte) ((value & BYTE_3_MASK) >> BYTE_3_SHIFT); + return result; + } + + /** + * Helper method to get the value as a Java long from four bytes starting at given array offset + * + * @param bytes the array of bytes + * @param offset the offset to start + * @return the correspondanding Java long value + */ + public static long getValue(byte[] bytes, int offset) { + long value = (bytes[offset + BYTE_3] << BYTE_3_SHIFT) & BYTE_3_MASK; + value += (bytes[offset + BYTE_2] << BYTE_2_SHIFT) & BYTE_2_MASK; + value += (bytes[offset + BYTE_1] << BYTE_1_SHIFT) & BYTE_1_MASK; + value += (bytes[offset] & BYTE_MASK); + return value; + } + + /** + * Helper method to get the value as a Java long from a four-byte array + * + * @param bytes the array of bytes + * @return the correspondanding Java long value + */ + public static long getValue(byte[] bytes) { + return getValue(bytes, 0); + } + + /** + * Override to make two instances with same value equal. + * + * @param o an object to compare + * @return true if the objects are equal + * @since 1.1 + */ + public boolean equals(Object o) { + if (o == null || !(o instanceof ZipLong)) { + return false; + } + return value == ((ZipLong) o).getValue(); + } + + /** + * Override to make two instances with same value equal. + * + * @return the value stored in the ZipLong + * @since 1.1 + */ + public int hashCode() { + return (int) value; + } + + public Object clone() { + try { + return super.clone(); + } catch (CloneNotSupportedException cnfe) { + // impossible + throw new RuntimeException(cnfe); + } + } +} diff --git a/plugin/src/main/java/top/niunaijun/blackobfuscator/core/utils/zip/ZipManager.java b/plugin/src/main/java/top/niunaijun/blackobfuscator/core/utils/zip/ZipManager.java new file mode 100644 index 0000000..91b5cac --- /dev/null +++ b/plugin/src/main/java/top/niunaijun/blackobfuscator/core/utils/zip/ZipManager.java @@ -0,0 +1,352 @@ +package top.niunaijun.blackobfuscator.core.utils.zip; + +import java.io.BufferedOutputStream; +import java.io.File; +import java.io.FileInputStream; +import java.io.FileOutputStream; +import java.io.IOException; +import java.io.InputStream; +import java.text.SimpleDateFormat; +import java.util.ArrayList; +import java.util.Collections; +import java.util.Comparator; +import java.util.Enumeration; +import java.util.HashMap; + +public class ZipManager { + public static final SimpleDateFormat DATE_FORMAT = new SimpleDateFormat("yy-MM-dd HH:mm"); + private final File file; + public final ZipFile zipFile; + private final ZipEntry[] ze; + private ZipOutputStream zos; + public File tmp; + +// public static void main(String[] args) { +// test1(); +// } +// private static void extractTest() { +// try { +// ZipManager zipManager = new ZipManager(new File("C:\\b.zip")); +// zipManager.extract(new ExtractCallback() { +// +// @Override +// public File filter(ZipEntry zipEntry, int current, int total) { +// System.out.print("正在解压文件(" + current + "/" + total + ").." + zipEntry.getName() + "\n"); +// File file = new File("C:\\b\\" + zipEntry.getName()); +// if (!file.isDirectory() && file.exists()) +// //noinspection ResultOfMethodCallIgnored +// file.delete(); +// return file; +// } +// +// @Override +// public void onProgress(long current, long total) { +// System.out.print((100 * current / total) + "%\n"); +// } +// +// @Override +// public void done(ZipEntry zipEntry, File file) { +// +// } +// }); +// System.out.print("done\n"); +// } catch (IOException e) { +// e.printStackTrace(); +// } +// } + +// private static void test2() { +// try { +// ZipManager zipManager = new ZipManager(new File("C:\\b.zip")); +// for (ZipEntry ze : zipManager.ze) { +// System.out.print(ze.getName() + " " + ze.getParent() + " " + ze.getSimpleName() + "\n"); +// } +// System.out.print("===================\n"); +// ArrayList+ *
This class will try to use {@link RandomAccessFile + * RandomAccessFile} when you know that the output is going to go to a + * file.
+ *+ *
If RandomAccessFile cannot be used, this implementation will use + * a Data Descriptor to store size and CRC information for {@link + * #DEFLATED DEFLATED} entries, this means, you don't need to + * calculate them yourself. Unfortunately this is not possible for + * the {@link #STORED STORED} method, here setting the CRC and + * uncompressed size information is required before {@link + * #putNextEntry putNextEntry} can be called.
+ */ +public class ZipOutputStream extends FilterOutputStream { + public static final int LEVEL_BEST = Deflater.BEST_COMPRESSION; + public static final int LEVEL_BETTER = 7; + public static final int LEVEL_DEFAULT = Deflater.DEFAULT_COMPRESSION; + public static final int LEVEL_FASTER = 3; + public static final int LEVEL_FASTEST = Deflater.BEST_SPEED; + + private static final int BYTE_MASK = 0xFF; + private static final int SHORT = 2; + private static final int WORD = 4; + public static final int BUFFER_SIZE = 10240; + /* + * Apparently Deflater.setInput gets slowed down a lot on Sun JVMs + * when it gets handed a really big buffer. See + * https://issues.apache.org/bugzilla/show_bug.cgi?id=45396 + * + * Using a buffer size of 8 kB proved to be a good compromise + */ + private static final int DEFLATER_BLOCK_SIZE = 8192; + + /** + * Compression method for deflated entries. + * + * @since 1.1 + */ + public static final int DEFLATED = java.util.zip.ZipEntry.DEFLATED; + + /** + * Default compression level for deflated entries. + * + * @since Ant 1.7 + */ + public static final int DEFAULT_COMPRESSION = Deflater.DEFAULT_COMPRESSION; + + /** + * Compression method for stored entries. + * + * @since 1.1 + */ + public static final int STORED = java.util.zip.ZipEntry.STORED; + + /** + * default encoding for file names and comment. + */ + static final String DEFAULT_ENCODING = null; + + /** + * General purpose flag, which indicates that filenames are + * written in utf-8. + */ + public static final int UFT8_NAMES_FLAG = 1 << 11; + + /** + * General purpose flag, which indicates that filenames are + * written in utf-8. + * + */ + public static final int EFS_FLAG = UFT8_NAMES_FLAG; + + /** + * Current entry. + * + * @since 1.1 + */ + private ZipEntry entry; + + /** + * The file comment. + * + * @since 1.1 + */ + private String comment = ""; + + /** + * Compression level for next entry. + * + * @since 1.1 + */ + private int level = DEFAULT_COMPRESSION; + + /** + * Has the compression level changed when compared to the last + * entry? + * + * @since 1.5 + */ + private boolean hasCompressionLevelChanged = false; + + /** + * Default compression method for next entry. + * + * @since 1.1 + */ + private int method = java.util.zip.ZipEntry.DEFLATED; + + /** + * List of ZipEntries written so far. + * + * @since 1.1 + */ + private final List+ *
For a list of possible values see http://java.sun.com/j2se/1.5.0/docs/guide/intl/encoding.doc.html. + * Defaults to the platform's default character encoding.
+ * + * @since 1.3 + */ + private String encoding = null; + + /** + * The zip encoding to use for filenames and the file comment. + *+ * This field is of internal use and will be set in {@link + * #setEncoding(String)}. + */ + private ZipEncoding zipEncoding = UTF8_ZIP_ENCODING; + + // CheckStyle:VisibilityModifier OFF - bc + + /** + * This Deflater object is used for output. + *
+ *
This attribute is only protected to provide a level of API + * backwards compatibility. This class used to extend {@link + * java.util.zip.DeflaterOutputStream DeflaterOutputStream} up to + * Revision 1.13.
+ * + * @since 1.14 + */ + protected Deflater def = new Deflater(level, true); + + /** + * This buffer servers as a Deflater. + *+ *
This attribute is only protected to provide a level of API + * backwards compatibility. This class used to extend {@link + * java.util.zip.DeflaterOutputStream DeflaterOutputStream} up to + * Revision 1.13.
+ * + * @since 1.14 + */ + protected byte[] buf = new byte[512]; + + // CheckStyle:VisibilityModifier ON + + /** + * Optional random access output. + * + * @since 1.14 + */ + private RandomAccessFile raf = null; + + /** + * whether to use the general purpose bit flag when writing UTF-8 + * filenames or not. + */ + private boolean useUTF8Flag = true; + + /** + * Whether to encode non-encodable file names as UTF-8. + */ + private boolean fallbackToUTF8 = false; + + /** + * whether to getInstance UnicodePathExtraField-s for each entry. + */ + private UnicodeExtraFieldPolicy createUnicodeExtraFields = + UnicodeExtraFieldPolicy.NEVER; + + /** + * Creates a new ZIP OutputStream filtering the underlying stream. + * + * @param out the outputstream to zip + * @since 1.1 + */ + public ZipOutputStream(OutputStream out) { + super(out); + } + + /** + * Creates a new ZIP OutputStream writing to a File. Will use + * random access if possible. + * + * @param file the file to zip to + * @throws IOException on error + * @since 1.14 + */ + public ZipOutputStream(File file) throws IOException { + //noinspection ConstantConditions + super(null); + + try { + raf = new RandomAccessFile(file, "rw"); + raf.setLength(0); + } catch (IOException e) { + if (raf != null) { + try { + raf.close(); + } catch (IOException inner) { + // ignore + } + raf = null; + } + out = new FileOutputStream(file); + } + } + + /** + * This method indicates whether this archive is writing to a + * seekable stream (i.e., to a random access file). + *+ *
For seekable streams, you don't need to calculate the CRC or + * uncompressed size for {@link #STORED} entries before + * invoking {@link #putNextEntry}. + * + * @return true if seekable + * @since 1.17 + */ + public boolean isSeekable() { + return raf != null; + } + + /** + * The encoding to use for filenames and the file comment. + *
+ *
For a list of possible values see http://java.sun.com/j2se/1.5.0/docs/guide/intl/encoding.doc.html. + * Defaults to the platform's default character encoding.
+ * + * @param encoding the encoding value + * @since 1.3 + */ + public void setEncoding(final String encoding) { + this.encoding = encoding; + boolean isUTF8 = ZipEncodingHelper.isUTF8(encoding); + this.zipEncoding = isUTF8 ? UTF8_ZIP_ENCODING : ZipEncodingHelper.getZipEncoding(encoding); + if (useUTF8Flag && !isUTF8) { + useUTF8Flag = false; + } + } + + public void setZipEncoding(final ZipEncoding zipEncoding) { + this.zipEncoding = zipEncoding; + this.encoding = zipEncoding.getEncoding(); + if (useUTF8Flag && !ZipEncodingHelper.isUTF8(encoding)) { + useUTF8Flag = false; + } + } + + + /** + * The encoding to use for filenames and the file comment. + * + * @return null if using the platform's default character encoding. + * @since 1.3 + */ + public String getEncoding() { + return encoding; + } + + /** + * Whether to set the language encoding flag if the file name + * encoding is UTF-8. + *+ *
Defaults to true.
+ */ + public void setUseLanguageEncodingFlag(boolean b) { + useUTF8Flag = b && ZipEncodingHelper.isUTF8(encoding); + } + + /** + * Whether to getInstance Unicode Extra Fields. + *+ *
Defaults to NEVER.
+ */ + public void setCreateUnicodeExtraFields(UnicodeExtraFieldPolicy b) { + createUnicodeExtraFields = b; + } + + /** + * Whether to fall back to UTF and the language encoding flag if + * the file name cannot be encoded using the specified encoding. + *+ *
Defaults to false.
+ */ + public void setFallbackToUTF8(boolean b) { + fallbackToUTF8 = b; + } + + /** + * Finishs writing the contents and closes this as well as the + * underlying stream. + * + * @throws IOException on error + * @since 1.1 + */ + public void finish() throws IOException { + closeEntry(); + cdOffset = written; + for (ZipEntry entry1 : entries) { + writeCentralFileHeader(entry1); + } + cdLength = written - cdOffset; + writeCentralDirectoryEnd(); + offsets.clear(); + entries.clear(); + def.end(); + } + + /** + * Writes all necessary data for this entry. + * + * @throws IOException on error + * @since 1.1 + */ + public void closeEntry() throws IOException { + if (entry == null) { + return; + } + + if (currentIsRawEntry) + crc.reset(); + else { + long realCrc = crc.getValue(); + crc.reset(); + + if (entry.getMethod() == DEFLATED) { + def.finish(); + while (!def.finished()) { + deflate(); + } + + entry.setSize(adjustToLong(def.getTotalIn())); + entry.setCompressedSize(adjustToLong(def.getTotalOut())); + entry.setCrc(realCrc); + + def.reset(); + + written += entry.getCompressedSize(); + } else if (raf == null) { + if (entry.getCrc() != realCrc) { + throw new ZipException("bad CRC checksum for entry " + + entry.getName() + ": " + + Long.toHexString(entry.getCrc()) + + " instead of " + + Long.toHexString(realCrc)); + } + + if (entry.getSize() != written - dataStart) { + throw new ZipException("bad size for entry " + + entry.getName() + ": " + + entry.getSize() + + " instead of " + + (written - dataStart)); + } + } else { /* method is STORED and we used RandomAccessFile */ + long size = written - dataStart; + + entry.setSize(size); + entry.setCompressedSize(size); + entry.setCrc(realCrc); + } + + // If random access output, write the local file header containing + // the correct CRC and compressed/uncompressed sizes + if (raf != null) { + long save = raf.getFilePointer(); + + raf.seek(localDataStart); + byte[] data = new byte[12]; + putLong(entry.getCrc(), data, 0); + putLong(entry.getCompressedSize(), data, 4); + putLong(entry.getSize(), data, 8); + writeOut(data); + raf.seek(save); + } + } + + writeDataDescriptor(entry); + entry = null; + } + + public void writeFully(InputStream is) throws IOException { + int len; + byte[] b = new byte[BUFFER_SIZE]; + while ((len = is.read(b)) > 0) + write(b, 0, len); + } + + public void copyZipEntry(ZipEntry zipEntry, ZipFile zipFile) throws IOException { + InputStream rawInputStream = zipFile.getRawInputStream(zipEntry); + if (rawInputStream == null) { + } + putNextRawEntry(zipEntry); + int len; + byte[] b = new byte[BUFFER_SIZE]; + while ((len = rawInputStream.read(b)) > 0) { + writeRaw(b, 0, len); + } + closeEntry(); + } + + private boolean currentIsRawEntry; + + public void putNextEntry(String entryName) throws IOException { + putNextEntry(new ZipEntry(entryName)); + } + + /** + * Begin writing next entry. + * + * @param ze the entry to write + * @throws IOException on error + * @since 1.1 + */ + public void putNextEntry(ZipEntry ze) throws IOException { + closeEntry(); + + entry = ze; + entries.add(entry); + + currentIsRawEntry = false; + + //noinspection WrongConstant + if (entry.getMethod() == -1) { // not specified + entry.setMethod(method); + } + + if (entry.getTime() == -1) { // not specified + entry.setTime(System.currentTimeMillis()); + } + + // Size/CRC not required if RandomAccessFile is used + if (entry.getMethod() == STORED && raf == null) { + if (entry.getSize() == -1) { + throw new ZipException("uncompressed size is required for" + + " STORED method when not writing to a" + + " file"); + } + if (entry.getCrc() == -1) { + throw new ZipException("crc checksum is required for STORED" + + " method when not writing to a file"); + } + entry.setCompressedSize(entry.getSize()); + } + + if (entry.getMethod() == DEFLATED && hasCompressionLevelChanged) { + def.setLevel(level); + hasCompressionLevelChanged = false; + } + writeLocalFileHeader(entry); + } + + public void putNextRawEntry(ZipEntry ze) throws IOException { + closeEntry(); + + entry = ze; + entries.add(entry); + + currentIsRawEntry = true; + + // Size/CRC not required if RandomAccessFile is used + if (entry.getMethod() == STORED && raf == null) { + if (entry.getSize() == -1) { + throw new ZipException("uncompressed size is required for" + + " STORED method when not writing to a" + + " file"); + } + if (entry.getCrc() == -1) { + throw new ZipException("crc checksum is required for STORED" + + " method when not writing to a file"); + } + entry.setCompressedSize(entry.getSize()); + } + + if (entry.getMethod() == DEFLATED && hasCompressionLevelChanged) { + def.setLevel(level); + hasCompressionLevelChanged = false; + } + writeLocalFileHeader(entry); + } + + /** + * Set the file comment. + * + * @param comment the comment + * @since 1.1 + */ + public void setComment(String comment) { + this.comment = comment; + } + + /** + * Sets the compression level for subsequent entries. + *+ *
Default is Deflater.DEFAULT_COMPRESSION.
+ * + * @param level the compression level. + * @throws IllegalArgumentException if an invalid compression + * level is specified. + * @since 1.1 + */ + public void setLevel(int level) { + if (level < Deflater.DEFAULT_COMPRESSION + || level > Deflater.BEST_COMPRESSION) { + throw new IllegalArgumentException("Invalid compression level: " + + level); + } + hasCompressionLevelChanged = (this.level != level); + this.level = level; + } + + /** + * Sets the default compression method for subsequent entries. + *+ *
Default is DEFLATED.
+ * + * @param method anint from java.util.zip.ZipEntry
+ * @since 1.1
+ */
+ public void setMethod(int method) {
+ this.method = method;
+ }
+
+ /**
+ * Writes bytes to ZIP entry.
+ *
+ * @param b the byte array to write
+ * @param offset the start position to write from
+ * @param length the number of bytes to write
+ * @throws IOException on error
+ */
+ public void write(byte[] b, int offset, int length) throws IOException {
+ if (entry.getMethod() == DEFLATED) {
+ if (length > 0) {
+ if (!def.finished()) {
+ if (length <= DEFLATER_BLOCK_SIZE) {
+ def.setInput(b, offset, length);
+ deflateUntilInputIsNeeded();
+ } else {
+ final int fullblocks = length / DEFLATER_BLOCK_SIZE;
+ for (int i = 0; i < fullblocks; i++) {
+ def.setInput(b, offset + i * DEFLATER_BLOCK_SIZE,
+ DEFLATER_BLOCK_SIZE);
+ deflateUntilInputIsNeeded();
+ }
+ final int done = fullblocks * DEFLATER_BLOCK_SIZE;
+ if (done < length) {
+ def.setInput(b, offset + done, length - done);
+ deflateUntilInputIsNeeded();
+ }
+ }
+ }
+ }
+ } else {
+ writeOut(b, offset, length);
+ written += length;
+ }
+ crc.update(b, offset, length);
+ }
+
+ public void writeRaw(byte[] b, int offset, int length) throws IOException {
+ writeOut(b, offset, length);
+ written += length;
+ }
+
+ public void writeRaw(byte[] b) throws IOException {
+ writeRaw(b, 0, b.length);
+ }
+
+ /**
+ * Writes a single byte to ZIP entry.
+ * + *
Delegates to the three arg method.
+ * + * @param b the byte to write + * @throws IOException on error + * @since 1.14 + */ + public void write(int b) throws IOException { + byte[] buff = new byte[1]; + buff[0] = (byte) (b & BYTE_MASK); + write(buff, 0, 1); + } + + /** + * Closes this output stream and releases any system resources + * associated with the stream. + * + * @throws IOException if an I/O error occurs. + * @since 1.14 + */ + public void close() throws IOException { + finish(); + + if (raf != null) { + raf.close(); + } + if (out != null) { + out.close(); + } + } + + /** + * Flushes this output stream and forces any buffered output bytes + * to be written out to the stream. + * + * @throws IOException if an I/O error occurs. + * @since 1.14 + */ + public void flush() throws IOException { + if (out != null) { + out.flush(); + } + } + + /* + * Various ZIP constants + */ + /** + * local file header signature + * + * @since 1.1 + */ + protected static final byte[] LFH_SIG = ZipLong.getBytes(0X04034B50L); + /** + * data descriptor signature + * + * @since 1.1 + */ + protected static final byte[] DD_SIG = ZipLong.getBytes(0X08074B50L); + /** + * central file header signature + * + * @since 1.1 + */ + protected static final byte[] CFH_SIG = ZipLong.getBytes(0X02014B50L); + /** + * end of central dir signature + * + * @since 1.1 + */ + protected static final byte[] EOCD_SIG = ZipLong.getBytes(0X06054B50L); + + /** + * Writes next block of compressed data to the output stream. + * + * @throws IOException on error + * @since 1.14 + */ + protected final void deflate() throws IOException { + int len = def.deflate(buf, 0, buf.length); + if (len > 0) { + writeOut(buf, 0, len); + } + } + + /** + * Writes the local file header entry + * + * @param ze the entry to write + * @throws IOException on error + * @since 1.1 + */ + protected void writeLocalFileHeader(ZipEntry ze) throws IOException { + + boolean encodable = zipEncoding.canEncode(ze.getName()); + + final ZipEncoding entryEncoding; + + if (!encodable && fallbackToUTF8) { + entryEncoding = UTF8_ZIP_ENCODING; + } else { + entryEncoding = zipEncoding; + } + + ByteBuffer name = entryEncoding.encode(ze.getName()); + + if (createUnicodeExtraFields != UnicodeExtraFieldPolicy.NEVER) { + + if (createUnicodeExtraFields == UnicodeExtraFieldPolicy.ALWAYS + || !encodable) { + ze.addExtraField(new UnicodePathExtraField(ze.getName(), + name.array(), + name.arrayOffset(), + name.limit())); + } + + String comm = ze.getComment(); + if (comm != null && !"".equals(comm)) { + + boolean commentEncodable = this.zipEncoding.canEncode(comm); + + if (createUnicodeExtraFields == UnicodeExtraFieldPolicy.ALWAYS + || !commentEncodable) { + ByteBuffer commentB = entryEncoding.encode(comm); + ze.addExtraField(new UnicodeCommentExtraField(comm, + commentB.array(), + commentB.arrayOffset(), + commentB.limit()) + ); + } + } + } + + offsets.put(ze, written); + + byte[] data = new byte[30 + name.limit()]; + + putBytes(LFH_SIG, data, 0); + written += WORD; + + //store method in local variable to prevent multiple method calls + final int zipMethod = ze.getMethod(); + + writeVersionNeededToExtractAndGeneralPurposeBits(data, 4, zipMethod, + !encodable && fallbackToUTF8); + written += WORD; + + // compression method + putShort(zipMethod, data, 8); + written += SHORT; + + // last mod. time and date + putLong(toDosTime(ze.getTime()), data, 10); + written += WORD; + + // CRC + // compressed length + // uncompressed length + localDataStart = written; + if (currentIsRawEntry) { + putLong(ze.getCrc(), data, 14); + putLong(ze.getCompressedSize(), data, 18); + putLong(ze.getSize(), data, 22); + } else if (zipMethod != DEFLATED && raf == null) { + putLong(ze.getCrc(), data, 14); + putLong(ze.getSize(), data, 18); + putLong(ze.getSize(), data, 22); + } +// else { +// writeOut(LZERO); +// writeOut(LZERO); +// writeOut(LZERO); +// } + // CheckStyle:MagicNumber OFF + written += 12; + // CheckStyle:MagicNumber ON + + // file name length + putShort(name.limit(), data, 26); + written += SHORT; + + // extra field length + byte[] extra = ze.getLocalFileDataExtra(); + if (ze.getMethod() == STORED) { + // ZipAlign对齐优化 + long len = written + SHORT + name.limit() + extra.length; + if (len % 4 != 0) { + int extraLen = 4 - (int) ((written + SHORT + name.limit()) % 4); + extra = new byte[extraLen]; + } + } + putShort(extra.length, data, 28); + written += SHORT; + + // file name + putBytes(name.array(), name.arrayOffset(), name.limit(), data, 30); + written += name.limit(); + + writeOut(data); + + // extra field + if (extra.length > 0) { + writeOut(extra); + written += extra.length; + } + + dataStart = written; + } + + private static void putBytes(byte[] value, int start, int length, byte[] buf, int offset) { + for (int i = 0; i < length; i++) { + buf[offset++] = value[start + i]; + } + } + + private static void putBytes(byte[] value, byte[] buf, int offset) { + putBytes(value, 0, value.length, buf, offset); + } + + + /** + * Writes the data descriptor entry. + * + * @param ze the entry to write + * @throws IOException on error + * @since 1.1 + */ + protected void writeDataDescriptor(ZipEntry ze) throws IOException { + if (ze.getMethod() != DEFLATED || raf != null) { + return; + } + byte[] data = new byte[16]; + putBytes(DD_SIG, data, 0); + putLong(entry.getCrc(), data, 4); + putLong(entry.getCompressedSize(), data, 8); + putLong(entry.getSize(), data, 12); + writeOut(data); + // CheckStyle:MagicNumber OFF + written += 16; + // CheckStyle:MagicNumber ON + } + + /** + * Writes the central file header entry. + * + * @param ze the entry to write + * @throws IOException on error + * @since 1.1 + */ + protected void writeCentralFileHeader(ZipEntry ze) throws IOException { + final int zipMethod = ze.getMethod(); + final boolean encodable = zipEncoding.canEncode(ze.getName()); + + final ZipEncoding entryEncoding; + + if (!encodable && fallbackToUTF8) { + entryEncoding = UTF8_ZIP_ENCODING; + } else { + entryEncoding = zipEncoding; + } + ByteBuffer name = entryEncoding.encode(ze.getName()); + + byte[] extra = ze.getCentralDirectoryExtra(); + + String comm = ze.getComment(); + if (comm == null) { + comm = ""; + } + + ByteBuffer commentB = entryEncoding.encode(comm); + + + byte[] data = new byte[46 + name.limit() + extra.length + commentB.limit()]; + + putBytes(CFH_SIG, data, 0); + written += WORD; + + // version made by + // CheckStyle:MagicNumber OFF + putShort((ze.getPlatform() << 8) | 20, data, 4); + written += SHORT; + + + writeVersionNeededToExtractAndGeneralPurposeBits(data, 6, zipMethod, + !encodable && fallbackToUTF8); + written += WORD; + + // compression method + putShort(zipMethod, data, 10); + written += SHORT; + + // last mod. time and date + putLong(toDosTime(ze.getTime()), data, 12); + written += WORD; + + // CRC + // compressed length + // uncompressed length + putLong(ze.getCrc(), data, 16); + putLong(ze.getCompressedSize(), data, 20); + putLong(ze.getSize(), data, 24); + // CheckStyle:MagicNumber OFF + written += 12; + // CheckStyle:MagicNumber ON + + // file name length + + putShort(name.limit(), data, 28); + written += SHORT; + + // extra field length + putShort(extra.length, data, 30); + written += SHORT; + + // file comment length + putShort(commentB.limit(), data, 32); + written += SHORT; + + // disk number start + written += SHORT; + + // internal file attributes + putShort(ze.getInternalAttributes(), data, 36); + written += SHORT; + + // external file attributes + putLong(ze.getExternalAttributes(), data, 38); + written += WORD; + + // relative offset of LFH + putLong(offsets.get(ze), data, 42); + written += WORD; + + // file name + putBytes(name.array(), name.arrayOffset(), name.limit(), data, 46); + written += name.limit(); + + // extra field + putBytes(extra, data, 46 + name.limit()); + written += extra.length; + + // file comment + putBytes(commentB.array(), commentB.arrayOffset(), commentB.limit(), + data, 46 + name.limit() + extra.length); + written += commentB.limit(); + writeOut(data); + } + + /** + * Writes the "End of central dir record". + * + * @throws IOException on error + * @since 1.1 + */ + protected void writeCentralDirectoryEnd() throws IOException { + ByteBuffer data = this.zipEncoding.encode(comment); + + byte[] buf = new byte[22 + data.limit()]; + putBytes(EOCD_SIG, buf, 0); +// putBytes(ZERO, buf, 4); +// putBytes(ZERO, buf, 6); + putShort(entries.size(), buf, 8); + putShort(entries.size(), buf, 10); + putLong(cdLength, buf, 12); + putLong(cdOffset, buf, 16); + putShort(data.limit(), buf, 20); + putBytes(data.array(), data.arrayOffset(), data.limit(), buf, 22); + writeOut(buf); +// writeOut(EOCD_SIG);//4 +// +// // disk numbers +// writeOut(ZERO);//2 +// writeOut(ZERO);//2 +// +// // number of entries +// byte[] num = ZipShort.getBytes(entries.size()); +// writeOut(num);//2 +// writeOut(num);//2 +// +// // length and location of CD +// writeOut(ZipLong.getBytes(cdLength));//4 +// writeOut(ZipLong.getBytes(cdOffset));//4 +// +// // ZIP file comment +// writeOut(ZipShort.getBytes(data.limit())); +// writeOut(data.array(), data.arrayOffset(), data.limit()); + } + + /** + * Smallest date/time ZIP can handle. + * + * @since 1.1 + */ +// private static final byte[] DOS_TIME_MIN = ZipLong.getBytes(0x00002100L); + + /** + * Convert a Date object to a DOS date/time field. + *+ *
Stolen from InfoZip's fileio.c
+ *
This implementation is not favorable for encodings other than + * utf-8, because java.io encodes unmappable character as question + * marks leading to unreadable ZIP entries on some operating + * systems.
+ *+ *
Furthermore this implementation is unable to tell, whether a + * given name can be safely encoded or not.
+ *+ *
The methods of this class are reentrant.
+ */ +@SuppressWarnings("ConstantConditions") +class FallbackZipEncoding implements ZipEncoding { + private final String charset; + private final DetectEncoding de; + + /** + * Construct a fallback zip encoding, which uses the platform's + * default charset. + */ + public FallbackZipEncoding() { + this.charset = null; + de = new DetectEncoding(); + } + + /** + * Construct a fallback zip encoding, which uses the given charset. + * + * @param charset The name of the charset or {@code null} for + * the platform's default character set. + */ + public FallbackZipEncoding(final String charset) { + this.charset = charset; + de = charset != null ? null : new DetectEncoding(); + } + + public boolean canEncode(final String name) { + return true; + } + + public ByteBuffer encode(final String name) throws IOException { + if (this.charset == null) { // i.e. use default charset, see no-args constructor + return ByteBuffer.wrap(name.getBytes(de.getEncode())); + } else { + return ByteBuffer.wrap(name.getBytes(this.charset)); + } + } + + public String decode(final byte[] data) throws IOException { + if (this.charset == null) { + de.update(data); + return new String(data, de.getEncode()); + } else { + return new String(data, this.charset); + } + } + + @Override + public String getEncoding() { + if (this.charset == null) + return de.getEncode().name(); + else + return this.charset; + } +} diff --git a/plugin/src/main/java/top/niunaijun/blackobfuscator/core/utils/zip/encoding/ZipEncoding.java b/plugin/src/main/java/top/niunaijun/blackobfuscator/core/utils/zip/encoding/ZipEncoding.java new file mode 100644 index 0000000..0a935ea --- /dev/null +++ b/plugin/src/main/java/top/niunaijun/blackobfuscator/core/utils/zip/encoding/ZipEncoding.java @@ -0,0 +1,88 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you under the Apache License, Version 2.0 (the + * "License"); you may not use this file except in compliance + * with the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, + * software distributed under the License is distributed on an + * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY + * KIND, either express or implied. See the License for the + * specific language governing permissions and limitations + * under the License. + */ + +package top.niunaijun.blackobfuscator.core.utils.zip.encoding; + +import java.io.IOException; +import java.nio.ByteBuffer; + +/** + * An interface for encoders that do a pretty encoding of ZIP + * filenames. + *+ *
There are mostly two implementations, one that uses java.nio + * {@link java.nio.charset.Charset Charset} and one implementation, + * which copes with simple 8 bit charsets, because java-1.4 did not + * support Cp437 in java.nio.
+ *+ *
The main reason for defining an own encoding layer comes from + * the problems with {@link String#getBytes(String) + * String.getBytes}, which encodes unknown characters as ASCII + * quotation marks ('?'). Quotation marks are per definition an + * invalid filename on some operating systems like Windows, which + * leads to ignored ZIP entries.
+ *+ *
All implementations should implement this interface in a + * reentrant way.
+ */ +public interface ZipEncoding { + + /** + * Check, whether the given string may be losslessly encoded using this + * encoding. + * + * @param name A filename or ZIP comment. + * @return Whether the given name may be encoded with out any losses. + */ + boolean canEncode(String name); + + /** + * Encode a filename or a comment to a byte array suitable for + * storing it to a serialized zip entry. + *+ *
Examples for CP 437 (in pseudo-notation, right hand side is + * C-style notation):
+ *
+ * encode("\u20AC_for_Dollar.txt") = "%U20AC_for_Dollar.txt"
+ * encode("\u00D6lf\u00E4sser.txt") = "\231lf\204sser.txt"
+ *
+ *
+ * @param name A filename or ZIP comment.
+ * @return A byte buffer with a backing array containing the
+ * encoded name. Unmappable characters or malformed
+ * character sequences are mapped to a sequence of utf-16
+ * words encoded in the format %Uxxxx. It is
+ * assumed, that the byte buffer is positioned at the
+ * beinning of the encoded result, the byte buffer has a
+ * backing array and the limit of the byte buffer points
+ * to the end of the encoded result.
+ * @throws IOException
+ */
+ ByteBuffer encode(String name) throws IOException;
+
+ /**
+ * @param data The byte values to decode.
+ * @return The decoded string.
+ * @throws IOException
+ */
+ String decode(byte[] data) throws IOException;
+
+ String getEncoding();
+
+}
diff --git a/plugin/src/main/java/top/niunaijun/blackobfuscator/core/utils/zip/encoding/ZipEncodingHelper.java b/plugin/src/main/java/top/niunaijun/blackobfuscator/core/utils/zip/encoding/ZipEncodingHelper.java
new file mode 100644
index 0000000..50a5cee
--- /dev/null
+++ b/plugin/src/main/java/top/niunaijun/blackobfuscator/core/utils/zip/encoding/ZipEncodingHelper.java
@@ -0,0 +1,32 @@
+package top.niunaijun.blackobfuscator.core.utils.zip.encoding;
+
+public class ZipEncodingHelper {
+ public static final ZipEncoding UTF8_ZIP_ENCODING = new FallbackZipEncoding("UTF-8");
+
+ /**
+ * name of the encoding UTF-8
+ */
+ static final String UTF8 = "UTF8";
+
+ /**
+ * variant name of the encoding UTF-8 used for comparisons.
+ */
+ private static final String UTF_DASH_8 = "utf-8";
+
+ /**
+ * Whether a given encoding - or the platform's default encoding
+ * if the parameter is null - is UTF-8.
+ */
+ public static boolean isUTF8(String encoding) {
+ if (encoding == null) {
+ // check platform's default encoding
+ encoding = System.getProperty("file.encoding");
+ }
+ return UTF8.equalsIgnoreCase(encoding)
+ || UTF_DASH_8.equalsIgnoreCase(encoding);
+ }
+
+ public static ZipEncoding getZipEncoding(String encoding) {
+ return new FallbackZipEncoding(encoding);
+ }
+}
diff --git a/plugin/src/main/java/top/niunaijun/blackobfuscator/core/utils/zip/extrafield/AbstractUnicodeExtraField.java b/plugin/src/main/java/top/niunaijun/blackobfuscator/core/utils/zip/extrafield/AbstractUnicodeExtraField.java
new file mode 100644
index 0000000..b787a64
--- /dev/null
+++ b/plugin/src/main/java/top/niunaijun/blackobfuscator/core/utils/zip/extrafield/AbstractUnicodeExtraField.java
@@ -0,0 +1,165 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+package top.niunaijun.blackobfuscator.core.utils.zip.extrafield;
+
+import top.niunaijun.blackobfuscator.core.utils.zip.ZipLong;
+import top.niunaijun.blackobfuscator.core.utils.zip.ZipShort;
+
+import java.io.UnsupportedEncodingException;
+import java.util.zip.CRC32;
+import java.util.zip.ZipException;
+
+/**
+ * A common base class for Unicode extra information extra fields.
+ */
+public abstract class AbstractUnicodeExtraField implements ZipExtraField {
+ private long nameCRC32;
+ private byte[] unicodeName;
+ private byte[] data;
+
+ protected AbstractUnicodeExtraField() {
+ }
+
+ /**
+ * Assemble as unicode extension from the name/comment and
+ * encoding of the orginal zip entry.
+ *
+ * @param text The file name or comment.
+ * @param bytes The encoded of the filename or comment in the zip
+ * file.
+ * @param off The offset of the encoded filename or comment in
+ * bytes.
+ * @param len The length of the encoded filename or commentin
+ * bytes.
+ */
+ protected AbstractUnicodeExtraField(String text, byte[] bytes, int off,
+ int len) {
+ CRC32 crc32 = new CRC32();
+ crc32.update(bytes, off, len);
+ nameCRC32 = crc32.getValue();
+
+ try {
+ unicodeName = text.getBytes("UTF-8");
+ } catch (UnsupportedEncodingException e) {
+ throw new RuntimeException("FATAL: UTF-8 encoding not supported.",
+ e);
+ }
+ }
+
+ /**
+ * Assemble as unicode extension from the name/comment and
+ * encoding of the orginal zip entry.
+ *
+ * @param text The file name or comment.
+ * @param bytes The encoded of the filename or comment in the zip
+ * file.
+ */
+ protected AbstractUnicodeExtraField(String text, byte[] bytes) {
+
+ this(text, bytes, 0, bytes.length);
+ }
+
+ private void assembleData() {
+ if (unicodeName == null) {
+ return;
+ }
+
+ data = new byte[5 + unicodeName.length];
+ // version 1
+ data[0] = 0x01;
+ System.arraycopy(ZipLong.getBytes(nameCRC32), 0, data, 1, 4);
+ System.arraycopy(unicodeName, 0, data, 5, unicodeName.length);
+ }
+
+ /**
+ * @return The CRC32 checksum of the filename or comment as
+ * encoded in the central directory of the zip file.
+ */
+ public long getNameCRC32() {
+ return nameCRC32;
+ }
+
+ /**
+ * @param nameCRC32 The CRC32 checksum of the filename as encoded
+ * in the central directory of the zip file to set.
+ */
+ public void setNameCRC32(long nameCRC32) {
+ this.nameCRC32 = nameCRC32;
+ data = null;
+ }
+
+ /**
+ * @return The utf-8 encoded name.
+ */
+ public byte[] getUnicodeName() {
+ return unicodeName;
+ }
+
+ /**
+ * @param unicodeName The utf-8 encoded name to set.
+ */
+ public void setUnicodeName(byte[] unicodeName) {
+ this.unicodeName = unicodeName;
+ data = null;
+ }
+
+ public byte[] getCentralDirectoryData() {
+ if (data == null) {
+ this.assembleData();
+ }
+ return data;
+ }
+
+ public ZipShort getCentralDirectoryLength() {
+ if (data == null) {
+ assembleData();
+ }
+ return new ZipShort(data.length);
+ }
+
+ public byte[] getLocalFileDataData() {
+ return getCentralDirectoryData();
+ }
+
+ public ZipShort getLocalFileDataLength() {
+ return getCentralDirectoryLength();
+ }
+
+ public void parseFromLocalFileData(byte[] buffer, int offset, int length)
+ throws ZipException {
+
+ if (length < 5) {
+ throw new ZipException("UniCode path extra data must have at least"
+ + " 5 bytes.");
+ }
+
+ int version = buffer[offset];
+
+ if (version != 0x01) {
+ throw new ZipException("Unsupported version [" + version
+ + "] for UniCode path extra data.");
+ }
+
+ nameCRC32 = ZipLong.getValue(buffer, offset + 1);
+ unicodeName = new byte[length - 5];
+ System.arraycopy(buffer, offset + 5, unicodeName, 0, length - 5);
+ data = null;
+ }
+
+}
diff --git a/plugin/src/main/java/top/niunaijun/blackobfuscator/core/utils/zip/extrafield/AsiExtraField.java b/plugin/src/main/java/top/niunaijun/blackobfuscator/core/utils/zip/extrafield/AsiExtraField.java
new file mode 100644
index 0000000..5b57661
--- /dev/null
+++ b/plugin/src/main/java/top/niunaijun/blackobfuscator/core/utils/zip/extrafield/AsiExtraField.java
@@ -0,0 +1,367 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+package top.niunaijun.blackobfuscator.core.utils.zip.extrafield;
+
+import top.niunaijun.blackobfuscator.core.utils.zip.UnixStat;
+import top.niunaijun.blackobfuscator.core.utils.zip.ZipLong;
+import top.niunaijun.blackobfuscator.core.utils.zip.ZipShort;
+
+import java.util.zip.CRC32;
+import java.util.zip.ZipException;
+
+
+/**
+ * Adds Unix file permission and UID/GID fields as well as symbolic
+ * link handling.
+ * + *
This class uses the ASi extra field in the format: + *
+ * Value Size Description + * ----- ---- ----------- + * (Unix3) 0x756e Short tag for this extra block type + * TSize Short total data size for this block + * CRC Long CRC-32 of the remaining data + * Mode Short file permissions + * SizDev Long symlink'd size OR major/minor dev num + * UID Short user ID + * GID Short group ID + * (var.) variable symbolic link filename + *+ * taken from appnote.iz (Info-ZIP note, 981119) found at ftp://ftp.uu.net/pub/archiving/zip/doc/ + *
+ *
+ *
Short is two bytes and Long is four bytes in big endian byte and + * word order, device numbers are currently not supported.
+ */ +public class AsiExtraField implements ZipExtraField, UnixStat, Cloneable { + + private static final ZipShort HEADER_ID = new ZipShort(0x756E); + private static final int WORD = 4; + /** + * Standard Unix stat(2) file mode. + * + * @since 1.1 + */ + private int mode = 0; + /** + * User ID. + * + * @since 1.1 + */ + private int uid = 0; + /** + * Group ID. + * + * @since 1.1 + */ + private int gid = 0; + /** + * File this entry points to, if it is a symbolic link. + *+ *
empty string - if entry is not a symbolic link.
+ * + * @since 1.1 + */ + private String link = ""; + /** + * Is this an entry for a directory? + * + * @since 1.1 + */ + private boolean dirFlag = false; + + /** + * Instance used to calculate checksums. + * + * @since 1.1 + */ + private CRC32 crc = new CRC32(); + + /** + * Constructor for AsiExtraField. + */ + public AsiExtraField() { + } + + /** + * The Header-ID. + * + * @return the value for the header id for this extrafield + * @since 1.1 + */ + public ZipShort getHeaderId() { + return HEADER_ID; + } + + /** + * Length of the extra field in the local file data - without + * Header-ID or length specifier. + * + * @return aZipShort for the length of the data of this extra field
+ * @since 1.1
+ */
+ public ZipShort getLocalFileDataLength() {
+ return new ZipShort(WORD // CRC
+ + 2 // Mode
+ + WORD // SizDev
+ + 2 // UID
+ + 2 // GID
+ + getLinkedFile().getBytes().length);
+ }
+
+ /**
+ * Delegate to local file data.
+ *
+ * @return the centralDirectory length
+ * @since 1.1
+ */
+ public ZipShort getCentralDirectoryLength() {
+ return getLocalFileDataLength();
+ }
+
+ /**
+ * The actual data to put into local file data - without Header-ID
+ * or length specifier.
+ *
+ * @return get the data
+ * @since 1.1
+ */
+ public byte[] getLocalFileDataData() {
+ // CRC will be added later
+ byte[] data = new byte[getLocalFileDataLength().getValue() - WORD];
+ System.arraycopy(ZipShort.getBytes(getMode()), 0, data, 0, 2);
+
+ byte[] linkArray = getLinkedFile().getBytes();
+ // CheckStyle:MagicNumber OFF
+ System.arraycopy(ZipLong.getBytes(linkArray.length),
+ 0, data, 2, WORD);
+
+ System.arraycopy(ZipShort.getBytes(getUserId()),
+ 0, data, 6, 2);
+ System.arraycopy(ZipShort.getBytes(getGroupId()),
+ 0, data, 8, 2);
+
+ System.arraycopy(linkArray, 0, data, 10, linkArray.length);
+ // CheckStyle:MagicNumber ON
+
+ crc.reset();
+ crc.update(data);
+ long checksum = crc.getValue();
+
+ byte[] result = new byte[data.length + WORD];
+ System.arraycopy(ZipLong.getBytes(checksum), 0, result, 0, WORD);
+ System.arraycopy(data, 0, result, WORD, data.length);
+ return result;
+ }
+
+ /**
+ * Delegate to local file data.
+ *
+ * @return the local file data
+ * @since 1.1
+ */
+ public byte[] getCentralDirectoryData() {
+ return getLocalFileDataData();
+ }
+
+ /**
+ * Set the user id.
+ *
+ * @param uid the user id
+ * @since 1.1
+ */
+ public void setUserId(int uid) {
+ this.uid = uid;
+ }
+
+ /**
+ * Get the user id.
+ *
+ * @return the user id
+ * @since 1.1
+ */
+ public int getUserId() {
+ return uid;
+ }
+
+ /**
+ * Set the group id.
+ *
+ * @param gid the group id
+ * @since 1.1
+ */
+ public void setGroupId(int gid) {
+ this.gid = gid;
+ }
+
+ /**
+ * Get the group id.
+ *
+ * @return the group id
+ * @since 1.1
+ */
+ public int getGroupId() {
+ return gid;
+ }
+
+ /**
+ * Indicate that this entry is a symbolic link to the given filename.
+ *
+ * @param name Name of the file this entry links to, empty String
+ * if it is not a symbolic link.
+ * @since 1.1
+ */
+ public void setLinkedFile(String name) {
+ link = name;
+ mode = getMode(mode);
+ }
+
+ /**
+ * Name of linked file
+ *
+ * @return name of the file this entry links to if it is a
+ * symbolic link, the empty string otherwise.
+ * @since 1.1
+ */
+ public String getLinkedFile() {
+ return link;
+ }
+
+ /**
+ * Is this entry a symbolic link?
+ *
+ * @return true if this is a symbolic link
+ * @since 1.1
+ */
+ public boolean isLink() {
+ return getLinkedFile().length() != 0;
+ }
+
+ /**
+ * File mode of this file.
+ *
+ * @param mode the file mode
+ * @since 1.1
+ */
+ public void setMode(int mode) {
+ this.mode = getMode(mode);
+ }
+
+ /**
+ * File mode of this file.
+ *
+ * @return the file mode
+ * @since 1.1
+ */
+ public int getMode() {
+ return mode;
+ }
+
+ /**
+ * Indicate whether this entry is a directory.
+ *
+ * @param dirFlag if true, this entry is a directory
+ * @since 1.1
+ */
+ public void setDirectory(boolean dirFlag) {
+ this.dirFlag = dirFlag;
+ mode = getMode(mode);
+ }
+
+ /**
+ * Is this entry a directory?
+ *
+ * @return true if this entry is a directory
+ * @since 1.1
+ */
+ public boolean isDirectory() {
+ return dirFlag && !isLink();
+ }
+
+ /**
+ * Populate data from this array as if it was in local file data.
+ *
+ * @param data an array of bytes
+ * @param offset the start offset
+ * @param length the number of bytes in the array from offset
+ * @throws ZipException on error
+ * @since 1.1
+ */
+ public void parseFromLocalFileData(byte[] data, int offset, int length)
+ throws ZipException {
+
+ long givenChecksum = ZipLong.getValue(data, offset);
+ byte[] tmp = new byte[length - WORD];
+ System.arraycopy(data, offset + WORD, tmp, 0, length - WORD);
+ crc.reset();
+ crc.update(tmp);
+ long realChecksum = crc.getValue();
+ if (givenChecksum != realChecksum) {
+ throw new ZipException("bad CRC checksum "
+ + Long.toHexString(givenChecksum)
+ + " instead of "
+ + Long.toHexString(realChecksum));
+ }
+
+ int newMode = ZipShort.getValue(tmp, 0);
+ // CheckStyle:MagicNumber OFF
+ byte[] linkArray = new byte[(int) ZipLong.getValue(tmp, 2)];
+ uid = ZipShort.getValue(tmp, 6);
+ gid = ZipShort.getValue(tmp, 8);
+
+ if (linkArray.length == 0) {
+ link = "";
+ } else {
+ System.arraycopy(tmp, 10, linkArray, 0, linkArray.length);
+ link = new String(linkArray);
+ }
+ // CheckStyle:MagicNumber ON
+ setDirectory((newMode & DIR_FLAG) != 0);
+ setMode(newMode);
+ }
+
+ /**
+ * Get the file mode for given permissions with the correct file type.
+ *
+ * @param mode the mode
+ * @return the type with the mode
+ * @since 1.1
+ */
+ protected int getMode(int mode) {
+ int type = FILE_FLAG;
+ if (isLink()) {
+ type = LINK_FLAG;
+ } else if (isDirectory()) {
+ type = DIR_FLAG;
+ }
+ return type | (mode & PERM_MASK);
+ }
+
+ public Object clone() {
+ try {
+ AsiExtraField cloned = (AsiExtraField) super.clone();
+ cloned.crc = new CRC32();
+ return cloned;
+ } catch (CloneNotSupportedException cnfe) {
+ // impossible
+ throw new RuntimeException(cnfe);
+ }
+ }
+}
diff --git a/plugin/src/main/java/top/niunaijun/blackobfuscator/core/utils/zip/extrafield/CentralDirectoryParsingZipExtraField.java b/plugin/src/main/java/top/niunaijun/blackobfuscator/core/utils/zip/extrafield/CentralDirectoryParsingZipExtraField.java
new file mode 100644
index 0000000..b7770a2
--- /dev/null
+++ b/plugin/src/main/java/top/niunaijun/blackobfuscator/core/utils/zip/extrafield/CentralDirectoryParsingZipExtraField.java
@@ -0,0 +1,40 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+package top.niunaijun.blackobfuscator.core.utils.zip.extrafield;
+
+import java.util.zip.ZipException;
+
+/**
+ * {@link ZipExtraField ZipExtraField} that knows how to parse central
+ * directory data.
+ *
+ * @since Ant 1.8.0
+ */
+public interface CentralDirectoryParsingZipExtraField extends ZipExtraField {
+ /**
+ * Populate data from this array as if it was in central directory data.
+ *
+ * @param data an array of bytes
+ * @param offset the start offset
+ * @param length the number of bytes in the array from offset
+ * @throws ZipException on error
+ */
+ void parseFromCentralDirectoryData(byte[] data, int offset, int length)
+ throws ZipException;
+}
diff --git a/plugin/src/main/java/top/niunaijun/blackobfuscator/core/utils/zip/extrafield/ExtraFieldUtils.java b/plugin/src/main/java/top/niunaijun/blackobfuscator/core/utils/zip/extrafield/ExtraFieldUtils.java
new file mode 100644
index 0000000..b7a63bd
--- /dev/null
+++ b/plugin/src/main/java/top/niunaijun/blackobfuscator/core/utils/zip/extrafield/ExtraFieldUtils.java
@@ -0,0 +1,324 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+package top.niunaijun.blackobfuscator.core.utils.zip.extrafield;
+
+import top.niunaijun.blackobfuscator.core.utils.zip.JarMarker;
+import top.niunaijun.blackobfuscator.core.utils.zip.ZipShort;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.zip.ZipException;
+
+
+/**
+ * ZipExtraField related methods
+ */
+// CheckStyle:HideUtilityClassConstructorCheck OFF (bc)
+public class ExtraFieldUtils {
+
+ private static final int WORD = 4;
+
+ /**
+ * Static registry of known extra fields.
+ *
+ * @since 1.1
+ */
+ private static final Map+ *
The given class must have a no-arg constructor and implement + * the {@link ZipExtraField ZipExtraField interface}.
+ * + * @param c the class to register + * @since 1.1 + */ + public static void register(Class c) { + try { + ZipExtraField ze = (ZipExtraField) c.newInstance(); + implementations.put(ze.getHeaderId(), c); + } catch (ClassCastException cc) { + throw new RuntimeException(c + " doesn\'t implement ZipExtraField"); + } catch (InstantiationException ie) { + throw new RuntimeException(c + " is not a concrete class"); + } catch (IllegalAccessException ie) { + throw new RuntimeException(c + "\'s no-arg constructor is not public"); + } + } + + /** + * Create an instance of the approriate ExtraField, falls back to + * {@link UnrecognizedExtraField UnrecognizedExtraField}. + * + * @param headerId the header identifier + * @return an instance of the appropiate ExtraField + * @throws InstantiationException if unable to instantiate the class + * @throws IllegalAccessException if not allowed to instatiate the class + * @since 1.1 + */ + public static ZipExtraField createExtraField(ZipShort headerId) + throws InstantiationException, IllegalAccessException { + Class c = implementations.get(headerId); + if (c != null) { + return (ZipExtraField) c.newInstance(); + } + UnrecognizedExtraField u = new UnrecognizedExtraField(); + u.setHeaderId(headerId); + return u; + } + + /** + * Split the array into ExtraFields and populate them with the + * given data as local file data, throwing an exception if the + * data cannot be parsed. + * + * @param data an array of bytes as it appears in local file data + * @return an array of ExtraFields + * @throws ZipException on error + */ + public static ZipExtraField[] parse(byte[] data) throws ZipException { + return parse(data, true, UnparseableExtraField.THROW); + } + + /** + * Split the array into ExtraFields and populate them with the + * given data, throwing an exception if the data cannot be parsed. + * + * @param data an array of bytes + * @param local whether data originates from the local file data + * or the central directory + * @return an array of ExtraFields + * @throws ZipException on error + * @since 1.1 + */ + public static ZipExtraField[] parse(byte[] data, boolean local) + throws ZipException { + return parse(data, local, UnparseableExtraField.THROW); + } + + /** + * Split the array into ExtraFields and populate them with the + * given data. + * + * @param data an array of bytes + * @param local whether data originates from the local file data + * or the central directory + * @param onUnparseableData what to do if the extra field data + * cannot be parsed. + * @return an array of ExtraFields + * @throws ZipException on error + * @since Ant 1.8.1 + */ + public static ZipExtraField[] parse(byte[] data, boolean local, + UnparseableExtraField onUnparseableData) + throws ZipException { + List+ *
Stores the UTF-8 version of the file comment as stored in the + * central directory header.
+ * + *
+ * Value Size Description
+ * ----- ---- -----------
+ * (UCom) 0x6375 Short tag for this extra block type ("uc")
+ * TSize Short total data size for this block
+ * Version 1 byte version of this extra field, currently 1
+ * ComCRC32 4 bytes Comment Field CRC32 Checksum
+ * UnicodeCom Variable UTF-8 version of the entry comment
+ *
+ */
+public class UnicodeCommentExtraField extends AbstractUnicodeExtraField {
+
+ public static final ZipShort UCOM_ID = new ZipShort(0x6375);
+
+ public UnicodeCommentExtraField() {
+ }
+
+ /**
+ * Assemble as unicode comment extension from the name given as
+ * text as well as the encoded bytes actually written to the archive.
+ *
+ * @param text The file name
+ * @param bytes the bytes actually written to the archive
+ * @param off The offset of the encoded comment in bytes.
+ * @param len The length of the encoded comment or comment in
+ * bytes.
+ */
+ public UnicodeCommentExtraField(String text, byte[] bytes, int off,
+ int len) {
+ super(text, bytes, off, len);
+ }
+
+ /**
+ * Assemble as unicode comment extension from the comment given as
+ * text as well as the bytes actually written to the archive.
+ *
+ * @param comment The file comment
+ * @param bytes the bytes actually written to the archive
+ */
+ public UnicodeCommentExtraField(String comment, byte[] bytes) {
+ super(comment, bytes);
+ }
+
+ public ZipShort getHeaderId() {
+ return UCOM_ID;
+ }
+
+}
diff --git a/plugin/src/main/java/top/niunaijun/blackobfuscator/core/utils/zip/extrafield/UnicodePathExtraField.java b/plugin/src/main/java/top/niunaijun/blackobfuscator/core/utils/zip/extrafield/UnicodePathExtraField.java
new file mode 100644
index 0000000..307b146
--- /dev/null
+++ b/plugin/src/main/java/top/niunaijun/blackobfuscator/core/utils/zip/extrafield/UnicodePathExtraField.java
@@ -0,0 +1,74 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+package top.niunaijun.blackobfuscator.core.utils.zip.extrafield;
+
+import top.niunaijun.blackobfuscator.core.utils.zip.ZipShort;
+
+/**
+ * Info-ZIP Unicode Path Extra Field (0x7075):
+ * + *
Stores the UTF-8 version of the file name field as stored in the + * local header and central directory header.
+ * + *
+ * Value Size Description
+ * ----- ---- -----------
+ * (UPath) 0x7075 Short tag for this extra block type ("up")
+ * TSize Short total data size for this block
+ * Version 1 byte version of this extra field, currently 1
+ * NameCRC32 4 bytes File Name Field CRC32 Checksum
+ * UnicodeName Variable UTF-8 version of the entry File Name
+ *
+ */
+public class UnicodePathExtraField extends AbstractUnicodeExtraField {
+
+ public static final ZipShort UPATH_ID = new ZipShort(0x7075);
+
+ public UnicodePathExtraField() {
+ }
+
+ /**
+ * Assemble as unicode path extension from the name given as
+ * text as well as the encoded bytes actually written to the archive.
+ *
+ * @param text The file name
+ * @param bytes the bytes actually written to the archive
+ * @param off The offset of the encoded filename in bytes.
+ * @param len The length of the encoded filename or comment in
+ * bytes.
+ */
+ public UnicodePathExtraField(String text, byte[] bytes, int off, int len) {
+ super(text, bytes, off, len);
+ }
+
+ /**
+ * Assemble as unicode path extension from the name given as
+ * text as well as the encoded bytes actually written to the archive.
+ *
+ * @param name The file name
+ * @param bytes the bytes actually written to the archive
+ */
+ public UnicodePathExtraField(String name, byte[] bytes) {
+ super(name, bytes);
+ }
+
+ public ZipShort getHeaderId() {
+ return UPATH_ID;
+ }
+}
diff --git a/plugin/src/main/java/top/niunaijun/blackobfuscator/core/utils/zip/extrafield/UnparseableExtraFieldData.java b/plugin/src/main/java/top/niunaijun/blackobfuscator/core/utils/zip/extrafield/UnparseableExtraFieldData.java
new file mode 100644
index 0000000..e197fb9
--- /dev/null
+++ b/plugin/src/main/java/top/niunaijun/blackobfuscator/core/utils/zip/extrafield/UnparseableExtraFieldData.java
@@ -0,0 +1,120 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+package top.niunaijun.blackobfuscator.core.utils.zip.extrafield;
+
+import top.niunaijun.blackobfuscator.core.utils.zip.ZipShort;
+import top.niunaijun.blackobfuscator.core.utils.zip.ZipUtil;
+
+/**
+ * Wrapper for extra field data that doesn't conform to the recommended format of header-tag + size + data.
+ * + *
The header-id is artificial (and not listed as a know ID in + * the .ZIP File Format Specification). + * Since it isn't used anywhere except to satisfy the + * ZipExtraField contract it shouldn't matter anyway.
+ * + * @see .ZIP File Format Specification + * @since Ant 1.8.1 + */ +public final class UnparseableExtraFieldData + implements CentralDirectoryParsingZipExtraField { + + private static final ZipShort HEADER_ID = new ZipShort(0xACC1); + + private byte[] localFileData; + private byte[] centralDirectoryData; + + /** + * The Header-ID. + * + * @return a completely arbitrary value that should be ignored. + */ + public ZipShort getHeaderId() { + return HEADER_ID; + } + + /** + * Length of the complete extra field in the local file data. + * + * @return The LocalFileDataLength value + */ + public ZipShort getLocalFileDataLength() { + return new ZipShort(localFileData == null ? 0 : localFileData.length); + } + + /** + * Length of the complete extra field in the central directory. + * + * @return The CentralDirectoryLength value + */ + public ZipShort getCentralDirectoryLength() { + return centralDirectoryData == null + ? getLocalFileDataLength() + : new ZipShort(centralDirectoryData.length); + } + + /** + * The actual data to put into local file data. + * + * @return The LocalFileDataData value + */ + public byte[] getLocalFileDataData() { + return ZipUtil.copy(localFileData); + } + + /** + * The actual data to put into central directory. + * + * @return The CentralDirectoryData value + */ + public byte[] getCentralDirectoryData() { + return centralDirectoryData == null + ? getLocalFileDataData() : ZipUtil.copy(centralDirectoryData); + } + + /** + * Populate data from this array as if it was in local file data. + * + * @param buffer the buffer to read data from + * @param offset offset into buffer to read data + * @param length the length of data + */ + public void parseFromLocalFileData(byte[] buffer, int offset, int length) { + localFileData = new byte[length]; + System.arraycopy(buffer, offset, localFileData, 0, length); + } + + /** + * Populate data from this array as if it was in central directory data. + * + * @param buffer the buffer to read data from + * @param offset offset into buffer to read data + * @param length the length of data + */ + public void parseFromCentralDirectoryData(byte[] buffer, int offset, + int length) { + centralDirectoryData = new byte[length]; + System.arraycopy(buffer, offset, centralDirectoryData, 0, length); + if (localFileData == null) { + parseFromLocalFileData(buffer, offset, length); + } + } + +} diff --git a/plugin/src/main/java/top/niunaijun/blackobfuscator/core/utils/zip/extrafield/UnrecognizedExtraField.java b/plugin/src/main/java/top/niunaijun/blackobfuscator/core/utils/zip/extrafield/UnrecognizedExtraField.java new file mode 100644 index 0000000..530f51e --- /dev/null +++ b/plugin/src/main/java/top/niunaijun/blackobfuscator/core/utils/zip/extrafield/UnrecognizedExtraField.java @@ -0,0 +1,164 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + */ + +package top.niunaijun.blackobfuscator.core.utils.zip.extrafield; + +import top.niunaijun.blackobfuscator.core.utils.zip.ZipShort; +import top.niunaijun.blackobfuscator.core.utils.zip.ZipUtil; + +/** + * Simple placeholder for all those extra fields we don't want to deal + * with. + *+ *
Assumes local file data and central directory entries are + * identical - unless told the opposite.
+ */ +public class UnrecognizedExtraField + implements CentralDirectoryParsingZipExtraField { + + /** + * The Header-ID. + * + * @since 1.1 + */ + private ZipShort headerId; + + /** + * Set the header id. + * + * @param headerId the header id to use + */ + public void setHeaderId(ZipShort headerId) { + this.headerId = headerId; + } + + /** + * Get the header id. + * + * @return the header id + */ + public ZipShort getHeaderId() { + return headerId; + } + + /** + * Extra field data in local file data - without + * Header-ID or length specifier. + * + * @since 1.1 + */ + private byte[] localData; + + /** + * Set the extra field data in the local file data - + * without Header-ID or length specifier. + * + * @param data the field data to use + */ + public void setLocalFileDataData(byte[] data) { + localData = ZipUtil.copy(data); + } + + /** + * Get the length of the local data. + * + * @return the length of the local data + */ + public ZipShort getLocalFileDataLength() { + return new ZipShort(localData.length); + } + + /** + * Get the local data. + * + * @return the local data + */ + public byte[] getLocalFileDataData() { + return ZipUtil.copy(localData); + } + + /** + * Extra field data in central directory - without + * Header-ID or length specifier. + * + * @since 1.1 + */ + private byte[] centralData; + + /** + * Set the extra field data in central directory. + * + * @param data the data to use + */ + public void setCentralDirectoryData(byte[] data) { + centralData = ZipUtil.copy(data); + } + + /** + * Get the central data length. + * If there is no central data, get the local file data length. + * + * @return the central data length + */ + public ZipShort getCentralDirectoryLength() { + if (centralData != null) { + return new ZipShort(centralData.length); + } + return getLocalFileDataLength(); + } + + /** + * Get the central data. + * + * @return the central data if present, else return the local file data + */ + public byte[] getCentralDirectoryData() { + if (centralData != null) { + return ZipUtil.copy(centralData); + } + return getLocalFileDataData(); + } + + /** + * @param data the array of bytes. + * @param offset the source location in the data array. + * @param length the number of bytes to use in the data array. + * @see ZipExtraField#parseFromLocalFileData(byte[], int, int) + */ + public void parseFromLocalFileData(byte[] data, int offset, int length) { + byte[] tmp = new byte[length]; + System.arraycopy(data, offset, tmp, 0, length); + setLocalFileDataData(tmp); + } + + /** + * @param data the array of bytes. + * @param offset the source location in the data array. + * @param length the number of bytes to use in the data array. + */ + public void parseFromCentralDirectoryData(byte[] data, int offset, + int length) { + byte[] tmp = new byte[length]; + System.arraycopy(data, offset, tmp, 0, length); + setCentralDirectoryData(tmp); + if (localData == null) { + setLocalFileDataData(tmp); + } + } + +} diff --git a/plugin/src/main/java/top/niunaijun/blackobfuscator/core/utils/zip/extrafield/ZipExtraField.java b/plugin/src/main/java/top/niunaijun/blackobfuscator/core/utils/zip/extrafield/ZipExtraField.java new file mode 100644 index 0000000..bfa80fb --- /dev/null +++ b/plugin/src/main/java/top/niunaijun/blackobfuscator/core/utils/zip/extrafield/ZipExtraField.java @@ -0,0 +1,92 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + */ + +package top.niunaijun.blackobfuscator.core.utils.zip.extrafield; + +import top.niunaijun.blackobfuscator.core.utils.zip.ZipShort; + +import java.util.zip.ZipException; + + +/** + * General format of extra field data. + *+ *
Extra fields usually appear twice per file, once in the local + * file data and once in the central directory. Usually they are the + * same, but they don't have to be. {@link + * java.util.zip.ZipOutputStream java.util.zip.ZipOutputStream} will + * only use the local file data in both places.
+ */ +public interface ZipExtraField { + + /** + * The Header-ID. + * + * @return the header id + * @since 1.1 + */ + ZipShort getHeaderId(); + + /** + * Length of the extra field in the local file data - without + * Header-ID or length specifier. + * + * @return the length of the field in the local file data + * @since 1.1 + */ + ZipShort getLocalFileDataLength(); + + /** + * Length of the extra field in the central directory - without + * Header-ID or length specifier. + * + * @return the length of the field in the central directory + * @since 1.1 + */ + ZipShort getCentralDirectoryLength(); + + /** + * The actual data to put into local file data - without Header-ID + * or length specifier. + * + * @return the data + * @since 1.1 + */ + byte[] getLocalFileDataData(); + + /** + * The actual data to put into central directory - without Header-ID or + * length specifier. + * + * @return the data + * @since 1.1 + */ + byte[] getCentralDirectoryData(); + + /** + * Populate data from this array as if it was in local file data. + * + * @param data an array of bytes + * @param offset the start offset + * @param length the number of bytes in the array from offset + * @throws ZipException on error + * @since 1.1 + */ + void parseFromLocalFileData(byte[] data, int offset, int length) + throws ZipException; +} diff --git a/plugin/src/main/resources/META-INF/gradle-plugins/top.niunaijun.blackobfuscator.properties b/plugin/src/main/resources/META-INF/gradle-plugins/top.niunaijun.blackobfuscator.properties new file mode 100644 index 0000000..ed1b3da --- /dev/null +++ b/plugin/src/main/resources/META-INF/gradle-plugins/top.niunaijun.blackobfuscator.properties @@ -0,0 +1 @@ +implementation-class=top.niunaijun.blackobfuscator.ObfPlugin \ No newline at end of file diff --git a/settings.gradle b/settings.gradle new file mode 100644 index 0000000..1d1f6d6 --- /dev/null +++ b/settings.gradle @@ -0,0 +1,3 @@ +rootProject.name = "BlackObfuscator-ASPlugin" +include ':app' +include ':plugin'