RFR for 6443578 and 6202130: UTF-8 in Manifests (original) (raw)

Wed May 2 05:21:37 UTC 2018

  /*
   * Writes the current attributes to the specified data output stream.
* XXX Need to handle UTF8 values and break up lines longer than 72
        String value = (String) e.getValue();
        if (value != null) {
            byte[] vb = value.getBytes("UTF8");
            value = new String(vb, 0, 0, vb.length);
        }
        buffer.append(value);
        Manifest.make72Safe(buffer);
        buffer.append("\r\n");
        os.writeBytes(buffer.toString());
    }
   os.writeBytes("\r\n");
   new ManifestWriter(os).writeSection(this);
}

/*
   if (version != null) {
       out.writeBytes(vername+": "+version+"\r\n");
   }
   // write out all attributes except for the version
   // we wrote out earlier
   for (Entry<Object, Object> e : entrySet()) {
       String name = ((Name) e.getKey()).toString();
       if ((version != null) && !(name.equalsIgnoreCase(vername))) {
           StringBuffer buffer = new StringBuffer(name);
           buffer.append(": ");
           String value = (String) e.getValue();
           if (value != null) {
               byte[] vb = value.getBytes("UTF8");
               value = new String(vb, 0, 0, vb.length);
           }
           buffer.append(value);
           Manifest.make72Safe(buffer);
           buffer.append("\r\n");
           out.writeBytes(buffer.toString());
       }
   }
   out.writeBytes("\r\n");
   new ManifestWriter(os).writeMain(this);
}

/*
 * Reads attributes from the specified input stream.
* XXX Need to handle UTF8 values.
 */
@SuppressWarnings("deprecation")
void read(Manifest.FastInputStream is, byte[] lbuf) throws
   DataOutputStream dos = new DataOutputStream(out);
   // Write out the main attributes for the manifest
   attr.writeMain(dos);
   // Now write out the per-entry attributes
   for (Map.Entry<String, Attributes> e : entries.entrySet()) {
       StringBuffer buffer = new StringBuffer("Name: ");
       String value = e.getKey();
       if (value != null) {
           byte[] vb = value.getBytes("UTF8");
           value = new String(vb, 0, 0, vb.length);
       }
       buffer.append(value);
       make72Safe(buffer);
       buffer.append("\r\n");
       dos.writeBytes(buffer.toString());
       e.getValue().write(dos);
   }
   dos.flush();
   new ManifestWriter(out).write(this);
}

/**
 * Adds line breaks to enforce a maximum 72 bytes per line.
*
* @see ManifestWriter#write72broken(String)
* @deprecated replaced by
* {@link ManifestWriter#write72broken(String)}
* which keeps whole utf character together when breaking lines
 */
* The utf-8 character set used for {@link Manifest}s.
*/
       StandardCharsets.UTF_8;
       INDIVIDUAL_SECTION_NAME_HEADER_KEY = "Name",
       KEY_VALUE_SEPARATOR = ": ",
       LINE_BREAK = "\r\n",
       CONTINUATION = " ";
* The underlying output stream where to write a {@link Manifest} to by
* {@link #write(Manifest)}.
*/
* Only constructor.
*
* @param out output stream where to write a {@link Manifest} to by
* {@link #write(Manifest)}
*/
   this.out = out;
   return value.getBytes(UTF_8);
   out.write(encode(value));
   out.write(value, off, len);
   out.write(LINE_BREAK_BUF);
       encode(LINE_BREAK + CONTINUATION);
   out.write(LINE_BREAK_CONTINUATION_BUF);
* Writes a header line with added line breaks to enforce a maximum
* bytes per line with respect only to breaks whole characters and
* the result to the current {@link ManifestWriter}'s underlying output
* stream.
*/
   byte[] buf = encode(header);
   int l = buf.length;
   int p = 0; // start position in buf of current line to write
   int n = MANIFEST_LINE_WIDTH; // number of bytes going on
   while (true) {
       if (p + n >= l) {
           n = l - p; // remainder fits on current (last) line
       } else {
           /*
            * break whole utf characters only:
            * put the current line end position on the next character
            * start position / utf non-continuation byte left of and
            * including n initial value / the maximum line width by
            * decreasing the current line end position n until not
            * followed by an utf continuation byte in order to not
            * utf characters across line breaks
            */
           while (!isNotUtfContinuationByte(buf[p + n])) n--;
       }
       write(buf, p, n);
       p += n;
       if (p == l) break;
       n = MANIFEST_LINE_WIDTH - 1;
       writeContinuationLineBreak();
   }
* @see StringCoding#isNotUtfContinuationByte(int)
* @see sun.nio.cs.UTF_8.Decoder#isNotUtfContinuationByte(int)
*/
   return (b & 0xc0) != 0x80;
   return name + KEY_VALUE_SEPARATOR + value;
   write72broken(composeHeaderLine(name, value));
   writeLineBreak();
* Writes the specified attributes to the current output stream.
*/
   for (Entry<Object, Object> e : attributes.entrySet()) {
       String name = ((Name) e.getKey()).toString();
       writeHeader(name, (String) e.getValue());
   }
   writeLineBreak();
* Writes the specified attributes to the current output stream,
* make sure to write out the MANIFEST_VERSION or SIGNATURE_VERSION
* attributes first.
*/
* XXX Need to handle version compliant to specification:
* - only digits and periods but no period at the beginning or end
* - not more than 72-16-1=55 characters in order not to exceed
* - no space after colon or rather change specs and only 54
*/
   // write out the *-Version header first, if it exists
   String vername = Name.MANIFEST_VERSION.toString();
   String version = attributes.getValue(vername);
   if (version == null) {
       vername = Name.SIGNATURE_VERSION.toString();
       version = attributes.getValue(vername);
   }
   if (version != null) {
       // version header cannot be continued on next line
       write(composeHeaderLine(vername, version));
       writeLineBreak();
   }
   // write out all attributes except for the version we wrote out
   for (Entry<Object, Object> e : attributes.entrySet()) {
       String name = ((Name) e.getKey()).toString();
       if ((version != null) && !(name.equalsIgnoreCase(vername))) {
           writeHeader(name, (String) e.getValue());
       }
   }
   writeLineBreak();
* Writes the given {@link Manifest} to the output stream of this
* {@link ManifestWriter} instance.
*
* @param mf the {@link Manifest} to write
*/
   // Write out the main attributes for the manifest
   writeMain(mf.getMainAttributes());
   // Now write out the per-entry attributes
   for (Entry<String, Attributes> e : mf.getEntries().entrySet()) {
       writeHeader(INDIVIDUAL_SECTION_NAME_HEADER_KEY, e.getKey());
       writeSection(e.getValue());
   }
     being used any longer by Manifest.
   void invoke(String name, DataOutputStream os) throws IOException {
       try {
           Method method = Attributes.class.getDeclaredMethod(
                   name, DataOutputStream.class);
           method.setAccessible(true);
           method.invoke(this, os);
       } catch (ReflectiveOperationException e) {
           fail(e.getMessage(), e);
       }
   }
   /**
    * @see Attributes#write(DataOutputStream)
    */
   void write(DataOutputStream os) throws IOException {
       invoke("write", os);
   }
   /**
    * @see Attributes#writeMain(DataOutputStream)
    */
   void writeMain(DataOutputStream os) throws IOException {
       invoke("writeMain", os);
   }
   ByteArrayOutputStream out = new ByteArrayOutputStream();
   AccessibleAttributes attributes = new AccessibleAttributes();
   attributes.put(Name.MANIFEST_VERSION, "1.0");
   attributes.put(KEY, VALUE);
   DataOutputStream dos = new DataOutputStream(out);
   attributes.writeMain(dos);
   attributes.remove(Name.MANIFEST_VERSION);
   dos.writeBytes("Name: " + VALUE + "\r\n");
   attributes.write(dos);
   dos.flush();
   byte[] mfBytes = out.toByteArray();
           + "-----------------------------");
   System.out.print(new String(mfBytes, UTF_8));
           + "-----------------------------");
   Manifest mf = new Manifest(new ByteArrayInputStream(mfBytes));
   assertEquals(mf.getMainAttributes().getValue(KEY), VALUE,
           "main attributes header value");
   Attributes attributes2 = mf.getAttributes(VALUE);
   assertNotNull(attributes2, "named section not found");
   assertEquals(attributes2.getValue(KEY), VALUE,
           "named section attributes header value");
     across lines in conjunction with multi-byte utf characters.
* By using names of four characters the same values can be used for
* testing line breaks at exact positions for both header and section
* names, header names in main and named sections, because a named
* section name is represented with a header with key "Name" that
* after a blank line and also has four characters.
*/
* Cover main attributes headers, section names, and headers in named
* sections because an implementation might make a difference.
*/
   MAIN_ATTRIBUTES, SECTION_NAME, NAMED_SECTION;
* @see LineBreakLineWidth#numByteUtfCharacter(int, int)
*/
   seed = seed < 0 ? -seed : seed;
   if (numBytes == 1) {
       seed %= 0x5F;
       seed += 0x20; // exclude control characters (0..0x19) here
   } else if (numBytes == 2) {
       seed %= 0x800 - 0x80;
       seed += 0x80;
   } else if (numBytes == 3) {
       seed %= 0x10000 - 0x800 + 0xFDD0 - 0xFDEF + 0xFFFE - 0xFFFF;
       seed += 0x800
               + (seed >= 0xFDD0 ? 0xFDEF - 0xFDD0 : 0) //
               + (seed % 0x10000) * (0xFFFF - 0xFFFE); // byte
   } else {
       seed %= 0x110000 - (0x10000 - 0xFFFE);
       seed += 0x10000
               + (seed % 0x10000) * (0xFFFF - 0xFFFE); // byte
   }
   String string = new String(Character.toChars(seed));
   assertEquals(string.getBytes(UTF_8).length, numBytes,
           "self-test failed: unexpected utf encoded character
   return string;
   LinkedList<Object[]> params = new LinkedList<>();
   // b: number of line breaks before character under test
   for (int b = 0; b <= 3; b++) {
      // c: character utf encoded length in bytes
      for (int c = 1; c <= 4; c++) {
           // p: potential break position offset in bytes
           // p = 0 => before character
           // p = c => after character and
           // 0 < p < c => character potentially broken across
           //              within the character
           for (int p = c; p >= 0; p--) {
               // a: no or one character following the one under test
               // (a = 0 meaning the character under test is
               // end of value which is also represented as a line
               for (int a = 0; a <= 1; a++) {
                   // offset: so many characters (actually bytes here
                   // filled with one byte characters) are needed
                   // the next character into a position relative
                   // maximum line width that it may or may not
                   // broken onto the next line
                   int offset =
                           // number of lines; - 1 is continuation
                           b * (MANIFEST_LINE_CONTENT_WIDTH_BYTES - 1)
                           // line length minus "Name: ".length()
                           + MANIFEST_LINE_CONTENT_WIDTH_BYTES - 6
                           // position of maximum line width
                           // beginning of encoded character
                           - p;
                   int seed = ((a * 2 + p) * c + c) * 4 + b;
                   String value = "";
                   for (int i = 0; i < offset - 1; i++) {
                       value += numByteUtfCharacter(1, seed++);
                   }
                   // character before the one to test the break
                   value += FILL;
                   String character = numByteUtfCharacter(c, seed);
                   value += character;
                   for (int i = 0; i < a; i++) {
                       // character after the one to test the break
                       value += FILL;
                   }
                   for (PositionInManifest i :
                           PositionInManifest.values()) {
                       params.add(new Object[] {
                               b, c, p, a, i, character, value});
                   }
               }
           }
       }
   }
   return params.toArray(new Object[0][0]);
* Checks that multi-byte utf characters work well with line breaks and
* continuation lines in jar manifests.
*
* Produces otherwise arbitrary manifests so that a specific character
* will not just fit on the same line and a line break and continuation
* line are required with:<ul>
* <li>different encoded sizes of characters: one, two, three, and four
* bytes per character (including also utf bmp and surrogate
* <li>different amount of space remaining on the same line or relative
* position of the latest possible line break position with respect
* character that can be continued on the same line or will have to be
* continued on the next line after a line break</li>
* <li>different number of preceding line breaks</li>
* </ul>
* For each of these cases the break position is verified in the binary
* manifest.
*/
       int a, PositionInManifest i, String character, String value)
               throws IOException {
   byte[] mfBytes = writeManifest(i, NAME, value);
   // expect the whole character on the next line unless it fits
   // completely on the current line
   boolean breakExpected = p < c;
   String brokenPart = character;
   if (breakExpected) {
       brokenPart = "\r\n " + brokenPart;
   }
   // expect a line break before the next character if there is a next
   // character and the previous not already broken on next line
   if (a == 1) {
       if (!breakExpected) {
           brokenPart += "\r\n ";
       }
       brokenPart += FILL;
   }
   brokenPart = FILL + brokenPart + "\r\n";
   assertOccurrence(mfBytes, brokenPart.getBytes(UTF_8));
   readManifestAndAssertValue(mfBytes, i, NAME, value);
       String value) throws IOException {
   Manifest mf = new Manifest();
   mf.getMainAttributes().put(Name.MANIFEST_VERSION, "1.0");
   Attributes attributes = new Attributes();
   switch (i) {
   case MAIN_ATTRIBUTES:
       mf.getMainAttributes().put(new Name(name), value);
       break;
   case SECTION_NAME:
       mf.getEntries().put(value, attributes);
       break;
   case NAMED_SECTION:
       mf.getEntries().put(NAME, attributes);
       attributes.put(new Name(name), value);
       break;
   }
   ByteArrayOutputStream out = new ByteArrayOutputStream();
   mf.write(out);
   byte[] mfBytes = out.toByteArray();
           + "-----------------------------");
   System.out.print(new String(mfBytes, UTF_8));
           + "-----------------------------");
   return mfBytes;
   List<Integer> matchPos = new LinkedList<>();
   for (int i = 0; i < mf.length; i++) {
       for (int j = 0; j < part.length && i + j <= mf.length; j++) {
           if (part[j] == 0) {
               if (i + j != mf.length) {
                   break; // expected eof not found
               }
           } else if (i + j == mf.length) {
               break;
           } else if (mf[i + j] != part[j]) {
               break;
           }
           if (j == part.length - 1) {
               matchPos.add(i);
           }
       }
   }
   assertEquals(matchPos.size(), 1, "not "
           + (matchPos.size() < 1 ? "found" : "unique") + ": '"
           + new String(part, UTF_8) + "'");
       byte[] mfBytes, PositionInManifest i, String name, String
               throws IOException {
   Manifest mf = new Manifest(new ByteArrayInputStream(mfBytes));
   switch (i) {
   case MAIN_ATTRIBUTES:
       assertEquals(mf.getMainAttributes().getValue(name), value,
               "main attributes header value");
       break;
   case SECTION_NAME:
       Attributes attributes = mf.getAttributes(value);
       assertNotNull(attributes, "named section not found");
       break;
   case NAMED_SECTION:
       attributes =
               mf.getAttributes(NAME);
       assertEquals(attributes.getValue(name), value,
               "named section attributes header value");
       break;
   }
       PositionInManifest i, String character, String value)
               throws IOException {
   byte[] mfBytes = writeManifestWithBrokenCharacters(i, NAME, value);
   ByteArrayOutputStream buf = new ByteArrayOutputStream();
   buf.write(FILL.getBytes(UTF_8));
   byte[] characterBytes = character.getBytes(UTF_8);
   // the portion of the character that fits on the current line
   // a break at 72 bytes, ranges from nothing (p == 0) to the whole
   // character (p == c)
   for (int j = 0; j < p; j++) {
       buf.write(characterBytes, j, 1);
   }
   // expect a line break at exactly 72 bytes from the beginning
   // line unless the whole character fits on that line
   boolean breakExpected = p < c;
   if (breakExpected) {
       buf.write("\r\n ".getBytes(UTF_8));
   }
   // the remaining portion of the character, if any
   for (int j = p; j < c; j++) {
       buf.write(characterBytes, j, 1);
   }
   // expect another linebreak if the whole character fitted on
   // line and there is another character
   if (a == 1) {
       if (c == p) {
           buf.write("\r\n ".getBytes(UTF_8));
       }
       buf.write(FILL.getBytes(UTF_8));
   }
   buf.write("\r\n".getBytes(UTF_8));
   byte[] brokenPart = buf.toByteArray();
   assertOccurrence(mfBytes, brokenPart);
   readManifestAndAssertValue(mfBytes, i, NAME, value);
* From previous Manifest implementation reduced to the minimum
* demonstrate compatibility
*/
       PositionInManifest i, String name, String value)
               throws IOException {
   byte[] vb = value.getBytes("UTF8");
   value = new String(vb, 0, 0, vb.length);
   ByteArrayOutputStream out = new ByteArrayOutputStream();
   DataOutputStream dos = new DataOutputStream(out);
   String vername = Name.MANIFEST_VERSION.toString();
   dos.writeBytes(vername + ": 0.1\r\n");
   if (i == PositionInManifest.MAIN_ATTRIBUTES) {
       StringBuffer buffer = new StringBuffer(name);
       buffer.append(": ");
       buffer.append(value);
       make72Safe(buffer);
       buffer.append("\r\n");
       dos.writeBytes(buffer.toString());
   }
   dos.writeBytes("\r\n");
   if (i == PositionInManifest.SECTION_NAME ||
           i == PositionInManifest.NAMED_SECTION) {
       StringBuffer buffer = new StringBuffer("Name: ");
       if (i == PositionInManifest.SECTION_NAME) {
           buffer.append(value);
       } else {
           buffer.append(NAME);
       }
       make72Safe(buffer);
       buffer.append("\r\n");
       dos.writeBytes(buffer.toString());
       if (i == PositionInManifest.NAMED_SECTION) {
           buffer = new StringBuffer(name);
           buffer.append(": ");
           buffer.append(value);
           make72Safe(buffer);
           buffer.append("\r\n");
           dos.writeBytes(buffer.toString());
       }
       dos.writeBytes("\r\n");
   }
   dos.flush();
   byte[] mfBytes = out.toByteArray();
           + "-----------------------------");
   System.out.print(new String(mfBytes, UTF_8));
           + "-----------------------------");
   return mfBytes;
* Adds line breaks to enforce a maximum 72 bytes per line.
* From previous Manifest implementation.
*/
   try {
       Method method = Manifest.class.getDeclaredMethod(
               "make72Safe", StringBuffer.class);
       method.setAccessible(true);
       method.invoke(null, line);
   } catch (ReflectiveOperationException e) {
       fail(e.getMessage(), e);
   }
     and read any line width
     lines, especially for 6372077 that the lines are
     to contain all possible valid header names, and read any line
     width.
  /**
* maximum line width not including the line break
*/
* tests if only valid manifest files can written depending on the
* Tests if only valid manifest files can written depending on the
* due to bug JDK-6372077 it was possible to write a manifest that
* not be read again. independent of the actual manifest line
* Due to bug JDK-6372077 it was possible to write a manifest that
* not be read again. Independent of the actual manifest line
* <p>
* While this test covers header names which can contain only
* encoded characters and the resulting manifest line widths,
* utf encoded characters can occur in header values, which is
* {@link #testManifestLineWidthMaximumRange()}.
 */
@Test
public void testWriteValidManifestOrException() throws IOException {
   assertTrue(TEST_WIDTH_RANGE > MAX_HEADER_NAME_LENGTH);
     /*
    * multi-byte utf-8 characters cannot occur in header names,
    * Multi-byte utf-8 characters cannot occur in header names,
     * only in values which are not subject of this test here.
    * hence, each character in a header name uses exactly one byte and
    * Hence, each character in a header name uses exactly one byte and
     * variable length utf-8 character encoding doesn't affect
  /**
* tests that manifest files can be read even if the line breaks are
* Tests that manifest files can be read even if the line breaks are
 * placed in different positions than where the current JDK's
 * {@link Manifest#write(java.io.OutputStream)} would have put it
* the <a
* "Notes on Manifest and Signature Files" in the "JAR File
* Specification"</a> state that "no line may be longer than 72 bytes
* (not characters), in its utf8-encoded form." but allows for
* The <a
* "Notes on Manifest and Signature Files"</a> in the "JAR File
* Specification" state that <q>no line may be longer than 72 bytes
* characters), in its utf8-encoded form.</q> but allows for earlier or
 * additional line breaks.
 * <p>
* the most important purpose of this test case is probably to make
* The most important purpose of this test case is probably to make
   String lineBrokenNameAndValue = breakLines(lineWidth, name + ":
   String lineBrokenNameAndValue = breakLines(lineWidth, name + ": "
               + value);

    ByteArrayOutputStream mfBuf = new ByteArrayOutputStream();
    mfBuf.write("Manifest-Version: 1.0".getBytes(UTF_8));
      assertEquals(value, mainValue, "value different in main section");
   Attributes attributes = mf.getAttributes(name);
   assertNotNull(attributes, "named section not found");
   String sectionValue = attributes.getValue(name);
    assertEquals(value, sectionValue, "value different in named
   testWriteVersionInfoLineWidth(Name.MANIFEST_VERSION);
   testWriteVersionInfoLineWidth(Name.SIGNATURE_VERSION);
* Tests that manifest versions "Manifest-Version" and
otherchar: any UTF-8 character except NUL, CR and LF+     *
+     * @see Jar File 
Specification
+     /
+    static boolean isInvalidManifestValueCharacter(int codePoint) {
+        return codePoint == 0 / NUL /
+            || codePoint == '\r' / CR /
+            || codePoint == '\n' / LF /;
+    };
+
+    /
     with multi-byte unicode characters broken across lines
/**
* this name will break across lines in MANIFEST.MF at the
* This name will break across lines in MANIFEST.MF at the
 * middle of a two-byte utf-8 encoded character due to its e acute
       + "D1234\u00E9xyz.class";
* Used for a test case where an entry / class file is added to an
       + "D1234567890.class";

static final String alias = "a";
static final String keystoreFileName = "test.jks";
   prepare();
   testSignJar("test.jar");
   testSignJarNoManifest("test-no-manifest.jar");
   testSignJarUpdate("test-update.jar", "test-updated.jar");
* Simulate a jar manifest as it would have been created by an
* by re-arranging the line break at exactly 72 bytes content thereby
* breaking the multi-byte character under test.
*/
   byte[] mf1 = new byte[mf0.length];
   int c0 = 0, c1 = 0; // bytes since last line start
   for (int i0 = 0, i1 = 0; i0 < mf0.length; i0++, i1++) {
       switch (mf0[i0]) {
       case '\r':
           if (i0 + 2 < mf0.length &&
                   mf0[i0 + 1] == '\n' && mf0[i0 + 2] == ' ') {
               // skip line break
               i0 += 2;
               i1 -= 1;
           } else {
               mf1[i1] = mf0[i0];
               c0 = c1 = 0;
           }
           break;
       case '\n':
           if (i0 + 1 < mf0.length && mf0[i0 + 1] == ' ') {
               // skip line break
               i0 += 1;
               i1 -= 1;
           } else {
               mf1[i1] = mf0[i0];
               c0 = c1 = 0;
           }
           break;
       case ' ':
           if (c0 == 0) {
               continue;
           }
       default:
           c0++;
           if (c1 == 72) {
               mf1[i1++] = '\r';
               mf1[i1++] = '\n';
               mf1[i1++] = ' ';
               c1 = 1;
           } else {
               c1++;
           }
           mf1[i1] = mf0[i0];
       }
   }
   return mf1;
}
   Files.write(Paths.get(manifestFileName), (Name.
           MANIFEST_VERSION.toString() + ":
   String jarFileName = "reference-manifest.jar";
   createJarWithManifest(jarFileName, manifestNoDigest,
           testClassName, anotherName);
   SecurityTools.jarsigner("-keystore", keystoreFileName,
           "JKS", "-storepass", "changeit", "-debug", jarFileName,
       .shouldHaveExitValue(0);
   try (ZipFile refJar = new ZipFile(jarFileName);) {
       ZipEntry mfEntry = refJar.getEntry(JarFile.MANIFEST_NAME);
       manifestWithDigest =
   }
   System.out.println("manifestWithDigest before re-break = " +
           new String(manifestWithDigest, UTF_8));
   manifestWithDigest = rebreak(manifestWithDigest);
   System.out.println("manifestWithDigest after re-break = " +
           new String(manifestWithDigest, UTF_8));
   // now, manifestWithDigest is accepted as unmodified by
   // jdk.security.jarsigner.JarSigner#updateDigests
   // (ZipEntry,ZipFile,MessageDigest[],Manifest) on line 985:
   // "if (!mfDigest.equalsIgnoreCase(base64Digests[i])) {"
   // and therefore left unchanged when the jar is signed and
   // signature verification will check it, which is the test case.
   Files.createDirectory(Paths.get("META-INF/"));
}
   JarUtils.createJar(jarFileName, manifestFileName, testClassName);
   verifyJarSignature(jarFileName);
   String jarFileName = "test-eacuteinonepiece.jar";
   createJarWithManifest(jarFileName, manifestNoDigest,
   signAndVerifyJarSignature(jarFileName, false);
}
   JarUtils.createJar(jarFileName, testClassName);
   verifyJarSignature(jarFileName);
   String jarFileName = "test-brokeneacute.jar";
   createJarWithManifest(jarFileName, manifestWithDigest,
   signAndVerifyJarSignature(jarFileName, true);
}
       String initialFileName, String updatedFileName) throws
   JarUtils.createJar(initialFileName, manifestFileName, anotherName);
   String jarFileName = "test-no-manifest.jar";
   JarUtils.createJar(jarFileName, testClassName);
   signAndVerifyJarSignature(jarFileName, false);
       throws Exception {
   String initialFileName = "test-eacuteinonepiece-update.jar";
   String updatedFileName = "test-eacuteinonepiece-updated.jar";
   createJarWithManifest(initialFileName, manifestNoDigest,
   verifyJarSignature(updatedFileName);
   signAndVerifyJarSignature(updatedFileName, false);
}
   // actually sign the jar
       throws Exception {
   String initialFileName = "test-brokeneacute-update.jar";
   String updatedFileName = "test-brokeneacute-updated.jar";
   createJarWithManifest(initialFileName, manifestWithDigest,
   SecurityTools.jarsigner("-keystore", keystoreFileName,
           "JKS", "-storepass", "changeit", "-debug", initialFileName,
           alias).shouldHaveExitValue(0);
   JarUtils.updateJar(initialFileName, updatedFileName,
   signAndVerifyJarSignature(updatedFileName, true);
       boolean expectBrokenEAcute) throws Exception {
    SecurityTools.jarsigner("-keystore", keystoreFileName,
       verifyClassNameLineBroken(jar, testClassName);
       verifyClassNameLineBroken(jar, testClassName,
  /**
* it would be too easy to miss the actual test case by just
* It would be too easy to miss the actual test case by just
* this check here verifies that the actual test case is tested
* This check here verifies that the actual test case is tested
*
* this relies on {@link java.util.jar.Manifest} breaking lines unaware
* of bytes that belong to the same multi-byte utf characters.
 */
       throws IOException {
       boolean expectBrokenEAcute) throws IOException {
    byte[] eAcute = "\u00E9".getBytes(UTF_8);
    byte[] eAcuteBroken =
            new byte[] {eAcute[0], '\r', '\n', ' ', eAcute[1]};
   if (jar.getManifest().getAttributes(className) == null) {
       throw new AssertionError(className + " not found in manifest");
   }
   assertNotNull(jar.getManifest().getAttributes(className),
           className + " not found in manifest");

    JarEntry manifestEntry = jar.getJarEntry(JarFile.MANIFEST_NAME);
   System.out.println("expectBrokenEAcute = " + expectBrokenEAcute);
   System.out.println("Manifest = \n" + new String(
           jar.getInputStream(manifestEntry).readAllBytes(), UTF_8));
     try (
         InputStream manifestIs = jar.getInputStream(manifestEntry);
     ) {
       if (bytesMatched < eAcuteBroken.length) {
           throw new AssertionError("self-test failed: multi-byte "
                   + "utf-8 character not broken across lines");
       }
       assertEquals(expectBrokenEAcute,
               bytesMatched == eAcuteBroken.length,
               "self-test failed: multi-byte "
               + "utf-8 character "
               + (expectBrokenEAcute ? "not " : "")
               + "broken across lines");
    }
}
   if (jarEntry.getCodeSigners() == null
           || jarEntry.getCodeSigners().length == 0) {
       throw new AssertionError(
               "no signing certificate found for " +
   }
   assertTrue(jarEntry.getCodeSigners() != null
           && jarEntry.getCodeSigners().length > 0,
           "no signing certificate found for " + jarEntry.getName());
       String... files) throws IOException {
   JarUtils.createJar("yetwithoutmanifest-" + jarFileName, files);
   JarUtils.updateJar("yetwithoutmanifest-" + jarFileName,
           new HashMap<>() {{ put(manifestFileName, manifest); }});
}

RFR for 6443578 and 6202130: UTF-8 in Manifests (original) (raw)

name, + static void assertMainAndSectionValues(Manifest mf, String name, String value) { String mainValue = mf.getMainAttributes().getValue(name); - String sectionValue = mf.getAttributes(name).getValue(name);

-/* - * @test - * @bug 6695402 - * @summary verify signatures of jars containing classes with names - * with multi-byte unicode characters broken across lines - * @library /test/lib - */

existing + * signed jar that already contains an entry with this name which of course + * has to be distinct from the one tested. + */ static final String anotherName =