/*
* Copyright (c) 2023, 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.
*/
/*
* @test
* @bug 8303623
* @modules jdk.compiler/com.sun.tools.javac.code
* @summary Compiler should disallow non-standard UTF-8 string encodings
*/
import com.sun.tools.javac.code.Source;
import com.sun.tools.javac.Main;
import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.PrintStream;
import java.io.PrintWriter;
import java.io.StringWriter;
import java.nio.file.Files;
import java.util.Arrays;
public class InvalidModifiedUtf8Test {
//
// What this test does (repeatedly):
// 1. Compile a Java source file for ClassX normally
// 2. Modify the UTF-8 inside the ClassX classfile so that it is
// still valid structurally but uses a non-standard way of
// encoding some character (according to "Modified UTF-8").
// 3. Compile a Java source file for RefClass that references ClassX
// 4. Verify that the compiler gives a "bad UTF-8" error
//
// We change c3 a8 -> c3 e8 (illegal second byte not of the form 0x10xxxxxx)
private static final String SOURCE_0 = """
interface CLASSNAME {
void ABC\u00e8(); // encodes to: 41 42 43 c3 a8
}
""";
// We change e1 80 80 -> e1 80 40 (illegal third byte not of the form 0x10xxxxxx)
private static final String SOURCE_1 = """
interface CLASSNAME {
void ABC\u1000(); // encodes to: 41 42 43 e1 80 80
}
""";
// We change c4 80 -> c1 81 (illegal two-byte encoding for one-byte value)
private static final String SOURCE_2 = """
interface CLASSNAME {
void ABC\u0100(); // encodes to: 41 42 43 c4 00
}
""";
// We change e1 80 80 -> e0 84 80 (illegal three-byte encoding for two-byte value)
private static final String SOURCE_3 = """
interface CLASSNAME {
void ABC\u1000(); // encodes to: 41 42 43 e1 80 80
}
""";
// We change 44 -> 00 (illegal one-byte encoding of 0x0000)
private static final String SOURCE_4 = """
interface CLASSNAME {
void ABCD(); // encodes to: 41 42 43 44
}
""";
// We change 43 44 -> e1 80 (illegal truncated three-byte encoding)
private static final String SOURCE_5 = """
interface CLASSNAME {
void ABCD(); // encodes to: 41 42 43 44
}
""";
// This is the source file that references one of the above
private static final String REF_SOURCE = """
interface RefClass extends CLASSNAME {
}
""";
private static TestCase[] TEST_CASES = new TestCase[] {
new TestCase(0, SOURCE_0, "414243c3a8", "414243c3e8"),
new TestCase(1, SOURCE_1, "414243e18080", "414243e18040"),
new TestCase(2, SOURCE_2, "414243c480", "414243c181"),
new TestCase(3, SOURCE_3, "414243e18080", "414243e08480"),
new TestCase(4, SOURCE_4, "41424344", "41424300"),
new TestCase(5, SOURCE_5, "41424344", "4142e180"),
};
public static String bytes2string(byte[] array) {
char[] buf = new char[array.length * 2];
for (int i = 0; i < array.length; i++) {
int value = array[i] & 0xff;
buf[i * 2] = Character.forDigit(value >> 4, 16);
buf[i * 2 + 1] = Character.forDigit(value & 0xf, 16);
}
return new String(buf);
}
public static byte[] string2bytes(String string) {
byte[] buf = new byte[string.length() / 2];
for (int i = 0; i < string.length(); i += 2) {
int value = Integer.parseInt(string.substring(i, i + 2), 16);
buf[i / 2] = (byte)value;
}
return buf;
}
private static void createSourceFile(String content, File file) throws IOException {
System.err.println("creating: " + file);
try (PrintStream output = new PrintStream(new FileOutputStream(file))) {
output.println(content);
}
}
private static void writeFile(File file, byte[] content) throws IOException {
System.err.println("writing: " + file);
try (FileOutputStream output = new FileOutputStream(file)) {
Files.write(file.toPath(), content);
}
}
private static void compileRefClass(File file, boolean expectSuccess, String expectedError) {
final StringWriter diags = new StringWriter();
final String[] params = new String[] {
"-classpath",
".",
"-XDrawDiagnostics",
file.toString()
};
System.err.println("compiling: " + file);
int ret = Main.compile(params, new PrintWriter(diags, true));
System.err.println("exit value: " + ret);
String output = diags.toString().trim();
if (!output.isEmpty())
System.err.println("output:\n" + output);
else
System.err.println("no output");
if (!expectSuccess && ret == 0)
throw new AssertionError("compilation succeeded, but expected failure");
else if (expectSuccess && ret != 0)
throw new AssertionError("compilation failed, but expected success");
if (expectedError != null && !diags.toString().contains(expectedError))
throw new AssertionError("expected output \"" + expectedError + "\" not found");
}
public static void main(String... args) throws Exception {
// Create source files
for (TestCase test : TEST_CASES)
test.createSourceFile();
// Compile source files
for (TestCase test : TEST_CASES) {
int ret = Main.compile(new String[] { test.sourceFile().toString() });
if (ret != 0)
throw new AssertionError("compilation of " + test.sourceFile() + " failed");
}
// We should get warnings in JDK 21 and errors in any later release
final boolean expectSuccess = Source.DEFAULT.compareTo(Source.JDK21) <= 0;
// Now compile REF_SOURCE against each classfile without and then with the modification.
// When compiling without the modification, everything should be normal.
// When compiling with the modification, an error should be generated.
for (TestCase test : TEST_CASES) {
System.err.println("==== TEST " + test.index() + " ====");
// Create reference source file
final File refSource = new File("RefClass.java");
createSourceFile(REF_SOURCE.replaceAll("CLASSNAME", test.className()), refSource);
// Do a normal compilation
compileRefClass(refSource, true, null);
// Now corrupt the class file
System.err.println("modifying: " + test.classFile());
final File classFile = test.classFile();
final byte[] data1 = Files.readAllBytes(classFile.toPath());
final byte[] data2 = test.modify(data1);
writeFile(classFile, data2);
// Do a corrupt compilation
compileRefClass(refSource, expectSuccess, "compiler.misc.bad.utf8.byte.sequence.at");
}
}
// TestCase
static class TestCase {
final int index;
final String source;
final String match;
final String replace;
TestCase(int index, String source, String match, String replace) {
this.index = index;
this.source = source.replaceAll("CLASSNAME", className());
this.match = match;
this.replace = replace;
}
byte[] modify(byte[] input) {
final byte[] output = string2bytes(bytes2string(input).replaceAll(match, replace));
if (Arrays.equals(output, input))
throw new AssertionError("modification of " + classFile() + " failed");
return output;
}
int index() {
return index;
}
String className() {
return "Class" + index;
}
File sourceFile() {
return new File(className() + ".java");
}
File classFile() {
return new File(className() + ".class");
}
void createSourceFile() throws IOException {
InvalidModifiedUtf8Test.createSourceFile(source, sourceFile());
}
}
}