/*

 * Copyright (c) 2009, Oracle and/or its affiliates. All rights reserved.

 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.

 *

 * This code is free software; you can redistribute it and/or modify it

 * under the terms of the GNU General Public License version 2 only, as

 * published by the Free Software Foundation.

 *

 * This code is distributed in the hope that it will be useful, but WITHOUT

 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or

 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License

 * version 2 for more details (a copy is included in the LICENSE file that

 * accompanied this code).

 *

 * You should have received a copy of the GNU General Public License version

 * 2 along with this work; if not, write to the Free Software Foundation,

 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.

 *

 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA

 * or visit www.oracle.com if you need additional information or have any

 * questions.

 */

/*

 * Borrowing significantly from Martin Buchholz's CorruptedZipFiles.java

 *

 * Needed a way of testing the checks for corrupt zip/jar entry in

 * inflate_file from file j2se/src/share/bin/parse_manifest.c

 * and running them with the 64-bit launcher. e.g.

 * sparcv9/bin/java -jar badjar.jar

 *

 * Run from a script driver Test6842838.sh as we want to specifically run

 * bin/sparcv9/java, the 64-bit launcher.

 *

 * So this program will create a zip file and damage it in the way

 * required to tickle this bug.

 *

 * It will cause a buffer overrun: but that will not always crash.

 * Use libumem preloaded by the script driver in order to

 * abort quickly when the overrun happens.  That makes the test

 * Solaris-specific.

 */

import java.util.*;

import java.util.zip.*;

import java.io.*;

import static java.lang.System.*;

import static java.util.zip.ZipFile.*;

public class CreateBadJar {

public static void main(String [] arguments) {

        if (arguments.length != 2) {

            throw new RuntimeException("Arguments: jarfilename entryname");

        }

        String outFile = arguments[0];

        String entryName = arguments[1];

        try {

        // If the named file doesn't exist, create it.

        // If it does, we are expecting it to contain the named entry, for

        // alteration.

        if (!new File(outFile).exists()) {

          System.out.println("Creating file " + outFile);

          // Create the requested zip/jar file.

          ZipOutputStream zos = null;

          zos = new ZipOutputStream(

            new FileOutputStream(outFile));

          ZipEntry e = new ZipEntry(entryName);

          zos.putNextEntry(e);

          for (int j=0; j<50000; j++) {

            zos.write((int)'a');

          }

          zos.closeEntry();

          zos.close();

          zos = null;

        }

        // Read it.

        int len = (int)(new File(outFile).length());

        byte[] good = new byte[len];

        FileInputStream fis = new FileInputStream(outFile);

        fis.read(good);

        fis.close();

        fis = null;

        int endpos = len - ENDHDR;

        int cenpos = u16(good, endpos+ENDOFF);

        if (u32(good, cenpos) != CENSIG) throw new RuntimeException("Where's CENSIG?");

        byte[] bad;

        bad = good.clone();

        // Corrupt it...

        int pos = findInCEN(bad, cenpos, entryName);

        // What bad stuff are we doing to it?

        // Store a 32-bit -1 in uncomp size.

        bad[pos+0x18]=(byte)0xff;

        bad[pos+0x19]=(byte)0xff;

        bad[pos+0x1a]=(byte)0xff;

        bad[pos+0x1b]=(byte)0xff;

        // Bad work complete, delete the original.

        new File(outFile).delete();

        // Write it.

        FileOutputStream fos = new FileOutputStream(outFile);

        fos.write(bad);

        fos.close();

        fos = null;

        } catch (Exception e) {

            e.printStackTrace();

        }

}

        /*

         * Scan Central Directory File Headers looking for the named entry.

         */

    static int findInCEN(byte[] bytes, int cenpos, String entryName) {

        int pos = cenpos;

        int nextPos = 0;

        String filename = null;

        do {

            if (nextPos != 0) {

                pos = nextPos;

            }

            System.out.println("entry at pos = " + pos);

            if (u32(bytes, pos) != CENSIG) throw new RuntimeException ("entry not found in CEN or premature end...");

            int csize = u32(bytes, pos+0x14);          // +0x14 1 dword csize

            int uncompsize = u32(bytes, pos+0x18);     // +0x18 1 dword uncomp size

            int filenameLength = u16(bytes, pos+0x1c); // +0x1c 1 word length of filename

            int extraLength = u16(bytes, pos+0x1e);    // +0x1e 1 world length of extra field

            int commentLength = u16(bytes, pos+0x20);  // +0x20 1 world length of file comment

            filename = new String(bytes, pos+0x2e, filenameLength); // +0x2e chars of filename

            int offset = u32(bytes, pos+0x2a);         // +0x2a chars of filename

            System.out.println("filename = " + filename + "\ncsize = " + csize +

                               " uncomp.size = " + uncompsize +" file offset = " + offset);

            nextPos =  pos + 0x2e + filenameLength + extraLength + commentLength;

        } while (!filename.equals(entryName));

        System.out.println("entry found at pos = " + pos);

        return pos;

    }

    static int u8(byte[] data, int offset) {

        return data[offset]&0xff;

    }

    static int u16(byte[] data, int offset) {

        return u8(data,offset) + (u8(data,offset+1)<<8);

    }

    static int u32(byte[] data, int offset) {

        return u16(data,offset) + (u16(data,offset+2)<<16);

    }

}