diff --git a/.grype.yaml b/.grype.yaml index d0b36edb..b953c589 100644 --- a/.grype.yaml +++ b/.grype.yaml @@ -60,6 +60,14 @@ ignore: # Remove this entry as soon as a patched braces is published and picked up by the lockfiles. - vulnerability: GHSA-vfj7-8cjw-p6xm + # source-map-js 1.2.1 (GHSA-68fv-2mgg-jv7q, High, published 2026-09-18): event-loop DoS through + # indexed source-map section offsets in untrusted source maps. Reached only through postcss and + # sass inside the Angular CLI build (ui/), which parses our own sources at build time; nothing of + # it is deployed. The fix, 1.2.2, exists (published 2026-09-30) but the repo's .npmrc + # (min-release-age=7) quarantines it until 2026-10-07. Accepted until then — bump and remove this + # entry per #348. + - vulnerability: GHSA-68fv-2mgg-jv7q + # Registry configuration (if needed for private registries) # registry: # auth: diff --git a/pom.xml b/pom.xml index c1829e83..a5927a59 100644 --- a/pom.xml +++ b/pom.xml @@ -134,6 +134,13 @@ + + + com.google.zxing + core + 3.5.3 + com.networknt json-schema-validator diff --git a/schemas/EN10168/v0.5.0/stylesheet.xsl b/schemas/EN10168/v0.5.0/stylesheet.xsl index ef38c34e..0c78efd6 100644 --- a/schemas/EN10168/v0.5.0/stylesheet.xsl +++ b/schemas/EN10168/v0.5.0/stylesheet.xsl @@ -1588,7 +1588,9 @@ - + diff --git a/src/main/java/com/materialidentity/schemaservice/CommandLineApp.java b/src/main/java/com/materialidentity/schemaservice/CommandLineApp.java index 190a5491..c69f10f5 100644 --- a/src/main/java/com/materialidentity/schemaservice/CommandLineApp.java +++ b/src/main/java/com/materialidentity/schemaservice/CommandLineApp.java @@ -202,8 +202,10 @@ private static void convertJsonToPdf(String inputFile, String outputFile, String } // Build PDF using the command-line builder pattern (with font loading fixes) + // The stylesheet renders a copy with every qr-code symbol generated (#346); the attached + // jsonContent is the certificate as issued. CommandLinePDFBuilder pdfBuilder = new CommandLinePDFBuilder() - .withXsltTransformer(new XsltTransformer(xsltSource, certificate, baseUri)) + .withXsltTransformer(new XsltTransformer(xsltSource, QrCodeValues.embedSymbols(certificate), baseUri)) .withTranslations(new TranslationLoader(translationsPattern, languages)) .withAttachment(new AttachmentManager(jsonContent, Paths.get(outputFile).getFileName().toString().replace(".pdf", ""), diff --git a/src/main/java/com/materialidentity/schemaservice/QrCodeValues.java b/src/main/java/com/materialidentity/schemaservice/QrCodeValues.java new file mode 100644 index 00000000..2dfefe01 --- /dev/null +++ b/src/main/java/com/materialidentity/schemaservice/QrCodeValues.java @@ -0,0 +1,69 @@ +// SPDX-License-Identifier: Apache-2.0 +package com.materialidentity.schemaservice; + +import com.fasterxml.jackson.databind.JsonNode; +import com.fasterxml.jackson.databind.node.ObjectNode; + +/** + * Generates the symbol of every {@code qr-code} key-value entry before the stylesheet runs (#346, mirrors schema#447). + * + *

EN10168 v0.5.0's {@code KeyValueObject.Type} has carried {@code qr-code} since the {@code url}, + * {@code phone}, {@code email} and {@code image} types were added, but nothing ever generated a + * symbol: the stylesheet drew whatever image the value happened to hold, so a certificate had to + * ship a hand-made picture next to the URL it showed. The rule now: the value is the text the + * symbol encodes (typically a URL) and the renderer generates the symbol. A value that is + * already a {@code data:} image URI keeps rendering as that image, so certificates issued under + * the earlier reading render exactly as before. + * + *

Done on the JSON rather than in XSLT because Saxon-HE has no QR encoder and the + * transformer factory registers no extension functions. The symbol arrives as an SVG {@code data:} URI, which + * the stylesheet's existing {@code fo:external-graphic} branch draws and the sandboxed FOP resolver + * admits without a fetch. Only the stylesheet sees the substituted document: the JSON attached to + * the PDF stays the certificate as issued. + */ +public final class QrCodeValues { + + /** The {@code Type} whose value is encoded. */ + static final String TYPE = "qr-code"; + + private QrCodeValues() { + } + + /** + * A copy of the certificate in which every encodable {@code qr-code} value is replaced by the + * SVG data URI of its symbol. The given node is not modified. + */ + public static JsonNode embedSymbols(JsonNode certificate) { + JsonNode copy = certificate.deepCopy(); + embedInto(copy); + return copy; + } + + private static void embedInto(JsonNode node) { + if (node.isObject()) { + // Children first: a Value is text, never an object, so nothing substituted is revisited. + node.forEach(QrCodeValues::embedInto); + ObjectNode object = (ObjectNode) node; + if (encodes(object)) { + object.put("Value", QrSymbol.of(object.get("Value").asText()).toSvgDataUri()); + } + } else if (node.isArray()) { + node.forEach(QrCodeValues::embedInto); + } + } + + /** A {@code qr-code} entry whose value is text to encode rather than a ready image. */ + static boolean encodes(JsonNode object) { + JsonNode type = object.get("Type"); + JsonNode value = object.get("Value"); + return type != null && TYPE.equals(type.asText()) + && value != null && value.isTextual() + && !value.asText().isBlank() + && !isDataUri(value.asText()); + } + + /** RFC 2397: the scheme is case-insensitive. */ + private static boolean isDataUri(String value) { + return value.regionMatches(true, 0, "data:", 0, 5); + } +} diff --git a/src/main/java/com/materialidentity/schemaservice/QrSymbol.java b/src/main/java/com/materialidentity/schemaservice/QrSymbol.java new file mode 100644 index 00000000..8b5ce3f6 --- /dev/null +++ b/src/main/java/com/materialidentity/schemaservice/QrSymbol.java @@ -0,0 +1,164 @@ +// SPDX-License-Identifier: Apache-2.0 +package com.materialidentity.schemaservice; + +import com.google.zxing.EncodeHintType; +import com.google.zxing.WriterException; +import com.google.zxing.common.BitMatrix; +import com.google.zxing.qrcode.decoder.ErrorCorrectionLevel; +import com.google.zxing.qrcode.encoder.ByteMatrix; +import com.google.zxing.qrcode.encoder.Encoder; +import com.google.zxing.qrcode.encoder.QRCode; + +import java.nio.charset.StandardCharsets; +import java.util.Base64; +import java.util.EnumMap; +import java.util.Map; + +/** + * One QR symbol (ISO/IEC 18004) encoding one string, emitted as SVG path data. + * + *

A copy of {@code QrSymbol} in material-identity/schema's {@code :shared} (schema#447), which the + * DPP data carrier and the legacy EN10168 pipeline there share; here it generates an EN10168 v0.5.0 + * {@code qr-code} key-value entry's symbol from its value (#346). Same encoder, quiet zone and path + * format, so a symbol rendered by either service is the same picture. + * + *

Vector rather than raster: a PNG would have to be either an external reference or a base64 + * blob that bloats every rendered view; path data is smaller, stays sharp when printed, and is the + * same input for an HTML view and an XSL-FO page. + * + *

The quiet zone is not decoration. ISO/IEC 18004 requires four modules of clear margin, and a + * QR printed flush against surrounding content is one many scanners will not read. + * + *

Error-correction level M (~15 %): the data is typically a URL of moderate length, and the + * symbol may end up on a label, a delivery note, or a certificate that has been folded and + * handled. L would be smaller and more fragile than that use deserves. + */ +public record QrSymbol( + String encodedData, + int moduleCount, + String pathData, + boolean[][] modules) { + + /** ISO/IEC 18004 requires a four-module clear margin around the symbol. */ + public static final int QUIET_ZONE = 4; + + private static final String SVG_DATA_URI_PREFIX = "data:image/svg+xml;base64,"; + + /** + * Encode one string. + * + * @throws IllegalArgumentException for a blank string (an empty QR is worse than none: it + * scans, and yields nothing) or one too long for a single symbol + */ + public static QrSymbol of(String data) { + if (data == null || data.isBlank()) { + throw new IllegalArgumentException("A QR symbol encodes a string; none was given"); + } + Map hints = new EnumMap<>(EncodeHintType.class); + hints.put(EncodeHintType.CHARACTER_SET, "UTF-8"); + + QRCode qr; + try { + qr = Encoder.encode(data, ErrorCorrectionLevel.M, hints); + } catch (WriterException e) { + throw new IllegalArgumentException( + "Cannot encode as one QR symbol (" + data.length() + " characters): " + + abbreviate(data), e); + } + + ByteMatrix matrix = qr.getMatrix(); + int size = matrix.getWidth(); + boolean[][] modules = new boolean[size][size]; + for (int y = 0; y < size; y++) { + for (int x = 0; x < size; x++) { + modules[y][x] = matrix.get(x, y) == 1; + } + } + + return new QrSymbol(data, size + 2 * QUIET_ZONE, buildPath(modules, size), modules); + } + + /** + * One SVG path covering every dark module, offset by the quiet zone. + * + *

A single path rather than one {@code } per module: a symbol of this size has several + * hundred dark modules, and the element-per-module form would add tens of kilobytes of markup + * to every rendered view for no visual difference. Horizontal runs are merged into one + * rectangle each, which roughly halves it again. + * + *

Returned as an attribute value, never as markup — so a stylesheet emits the SVG elements + * itself and nothing has to escape past the serializer. + */ + private static String buildPath(boolean[][] modules, int size) { + StringBuilder path = new StringBuilder(); + for (int y = 0; y < size; y++) { + int runStart = -1; + for (int x = 0; x <= size; x++) { + boolean dark = x < size && modules[y][x]; + if (dark && runStart < 0) { + runStart = x; + } else if (!dark && runStart >= 0) { + int width = x - runStart; + path.append('M').append(runStart + QUIET_ZONE).append(' ').append(y + QUIET_ZONE) + .append('h').append(width).append("v1h-").append(width).append('z'); + runStart = -1; + } + } + } + return path.toString(); + } + + /** + * The symbol as a zxing {@link BitMatrix}, without the quiet zone. + * + *

Exists so a test can decode the symbol back and assert it yields the encoded string + * exactly. That round trip is what turns "the symbol encodes the value" from a claim in a + * comment into a verified property. + */ + public BitMatrix toBitMatrix() { + int size = modules.length; + BitMatrix bits = new BitMatrix(size, size); + for (int y = 0; y < size; y++) { + for (int x = 0; x < size; x++) { + if (modules[y][x]) { + bits.set(x, y); + } + } + } + return bits; + } + + /** + * A standalone SVG document: black modules on a white ground, quiet zone included, scaling + * crisply to any size. The encoded string travels in {@code data-encoded} and in the title, so + * a viewer can say what the symbol opens without decoding it. + */ + public String toSvg() { + int n = moduleCount; + String text = escape(encodedData); + return "" + + "" + text + "" + + "" + + "" + + "\n"; + } + + /** + * {@link #toSvg()} as a {@code data:} URI, so a stylesheet's {@code fo:external-graphic} can draw + * the symbol with no resource fetch at all. + */ + public String toSvgDataUri() { + return SVG_DATA_URI_PREFIX + + Base64.getEncoder().encodeToString(toSvg().getBytes(StandardCharsets.UTF_8)); + } + + private static String escape(String s) { + return s.replace("&", "&").replace("<", "<").replace(">", ">").replace("\"", """); + } + + private static String abbreviate(String s) { + return s.length() <= 80 ? s : s.substring(0, 77) + "..."; + } +} diff --git a/src/main/java/com/materialidentity/schemaservice/service/SchemasServiceImpl.java b/src/main/java/com/materialidentity/schemaservice/service/SchemasServiceImpl.java index 2d484c14..007b9407 100644 --- a/src/main/java/com/materialidentity/schemaservice/service/SchemasServiceImpl.java +++ b/src/main/java/com/materialidentity/schemaservice/service/SchemasServiceImpl.java @@ -35,6 +35,7 @@ import com.materialidentity.schemaservice.PDFBuilder; import com.materialidentity.schemaservice.TranslationLoader; import com.materialidentity.schemaservice.WatermarkManager; +import com.materialidentity.schemaservice.QrCodeValues; import com.materialidentity.schemaservice.XsltTransformer; import com.materialidentity.schemaservice.config.SchemaControllerConstants; import com.materialidentity.schemaservice.config.SchemasAndVersions; @@ -206,8 +207,10 @@ public ResponseEntity renderPdf(Boolean attachJson, JsonNode certificate // Derive classpath root URI so json-doc() can resolve relative paths String baseUri = deriveClasspathRootUri(xsltResource, xsltPath); + // The stylesheet renders a copy with every qr-code symbol generated (#346); the JSON attached + // below (certificateJson) is the certificate as issued. PDFBuilder pdfBuilder = new PDFBuilder() - .withXsltTransformer(new XsltTransformer(xsltSource, certificate, baseUri)) + .withXsltTransformer(new XsltTransformer(xsltSource, QrCodeValues.embedSymbols(certificate), baseUri)) .withTranslations(new TranslationLoader(translationsPattern, languages)) .withAttachment( new AttachmentManager(certificateJson, diff --git a/src/test/java/com/materialidentity/schemaservice/QrCodeValuesTest.java b/src/test/java/com/materialidentity/schemaservice/QrCodeValuesTest.java new file mode 100644 index 00000000..42ae94c8 --- /dev/null +++ b/src/test/java/com/materialidentity/schemaservice/QrCodeValuesTest.java @@ -0,0 +1,119 @@ +package com.materialidentity.schemaservice; + +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertFalse; +import static org.junit.jupiter.api.Assertions.assertTrue; + +import com.fasterxml.jackson.databind.JsonNode; +import com.fasterxml.jackson.databind.ObjectMapper; +import com.fasterxml.jackson.databind.node.ObjectNode; +import java.nio.charset.StandardCharsets; +import java.nio.file.Files; +import java.nio.file.Path; +import java.nio.file.Paths; +import java.util.Base64; +import java.util.regex.Matcher; +import java.util.regex.Pattern; +import org.junit.jupiter.api.DisplayName; +import org.junit.jupiter.api.Test; + +/** + * EN10168 v0.5.0 {@code qr-code} entries get their symbol generated at render time (#346, mirrors + * material-identity/schema#447): the value is the text the symbol encodes, a ready {@code data:} + * image is left alone, and the given certificate is never modified. Asserted on the JSON + * substitution and on the generated XSL-FO — {@link RenderTest} compares extracted text only, and + * a symbol has none; it does assert that the JSON attached to the PDF is the fixture as issued. + */ +class QrCodeValuesTest { + + private static final ObjectMapper MAPPER = new ObjectMapper(); + private static final Path FIXTURE = Paths.get("test", "fixtures", "EN10168", "v0.5.0", "valid_certificate_11.json"); + private static final Path STYLESHEET = Paths.get("schemas", "EN10168", "v0.5.0", "stylesheet.xsl"); + private static final String URL = "https://dpp.example.org/dpp/steelmill/1607219-0001"; + private static final String PNG = "data:image/png;base64,iVBORw0KGgo="; + + private static ObjectNode entry(String type, String value) { + ObjectNode entry = MAPPER.createObjectNode(); + entry.put("Key", "Digital Product Passport"); + if (value != null) entry.put("Value", value); + entry.put("Type", type); + return entry; + } + + private static String svgOf(String dataUri) { + assertTrue(dataUri.startsWith("data:image/svg+xml;base64,"), dataUri.substring(0, Math.min(40, dataUri.length()))); + return new String(Base64.getDecoder().decode(dataUri.substring(dataUri.indexOf(',') + 1)), StandardCharsets.UTF_8); + } + + @Test + @DisplayName("A qr-code value is replaced by the SVG data URI of the symbol encoding it") + void urlBecomesTheSymbol() { + JsonNode out = QrCodeValues.embedSymbols(entry("qr-code", URL)); + assertEquals(QrSymbol.of(URL).toSvg(), svgOf(out.get("Value").asText())); + assertEquals("qr-code", out.get("Type").asText()); + assertEquals("Digital Product Passport", out.get("Key").asText()); + } + + @Test + @DisplayName("A ready data: image keeps rendering as that image — certificates issued earlier do not change") + void readyImageIsLeftAlone() { + assertEquals(PNG, QrCodeValues.embedSymbols(entry("qr-code", PNG)).get("Value").asText()); + String upper = "DATA:image/png;base64,iVBORw0KGgo="; + assertEquals(upper, QrCodeValues.embedSymbols(entry("qr-code", upper)).get("Value").asText()); + } + + @Test + @DisplayName("Every other type, a blank value and a missing value are untouched") + void onlyEncodableQrCodeEntriesChange() { + for (String type : new String[] {"url", "string", "image"}) { + assertEquals(URL, QrCodeValues.embedSymbols(entry(type, URL)).get("Value").asText(), type); + } + assertEquals(" ", QrCodeValues.embedSymbols(entry("qr-code", " ")).get("Value").asText()); + assertFalse(QrCodeValues.embedSymbols(entry("qr-code", null)).has("Value")); + } + + @Test + @DisplayName("Entries are found anywhere in the certificate, and the given node is not modified") + void walksTheWholeCertificateWithoutMutatingIt() throws Exception { + JsonNode cert = MAPPER.readTree(FIXTURE.toFile()); + ((ObjectNode) cert.at("/Certificate/Validation/SupplementaryInformation")) + .set("Z10", entry("qr-code", URL)); + String before = cert.toString(); + + JsonNode out = QrCodeValues.embedSymbols(cert); + + assertEquals(before, cert.toString(), "the certificate handed in must stay as issued"); + assertEquals(URL, out.at("/Certificate/ProductDescription/SupplementaryInformation/B20/Value").asText()); + for (String pointer : new String[] { + "/Certificate/ProductDescription/SupplementaryInformation/B21/Value", + "/Certificate/Validation/SupplementaryInformation/Z10/Value"}) { + assertEquals(QrSymbol.of(URL).toSvg(), svgOf(out.at(pointer).asText()), pointer); + } + } + + @Test + @DisplayName("The B-section reaches the stylesheet's qr-code branch: B20 links, B21 draws the symbol") + void foDrawsTheSymbolNextToTheLink() throws Exception { + String fo = renderFo(FIXTURE); + assertTrue(fo.contains(""), "B20 should be a link"); + Matcher graphic = Pattern.compile( + "]*src=\"(data:image/svg\\+xml;base64,[^\"]*)\"[^>]*/>").matcher(fo); + assertTrue(graphic.find(), "B21 should be drawn from an SVG data URI"); + assertEquals(QrSymbol.of(URL).toSvg(), svgOf(graphic.group(1))); + // The URL is printed once, as B20's link text; B21 carries it only inside the symbol. + assertEquals(1, Pattern.compile(Pattern.quote(">" + URL + "<")).matcher(fo).results().count()); + assertTrue(fo.contains("B21 "), "the B21 key row is still printed"); + } + + /** The certificate's XSL-FO as the service hands it to FOP, with the working-tree stylesheet. */ + static String renderFo(Path fixture) throws Exception { + JsonNode cert = MAPPER.readTree(fixture.toFile()); + JsonNode rendered = QrCodeValues.embedSymbols(cert); + String[] languages = MAPPER.convertValue(cert.at("/Certificate/CertificateLanguages"), String[].class); + String translationsPattern = Paths.get("schemas", "EN10168", "v0.5.0", "translation*.json").toString(); + ((ObjectNode) rendered).set("Translations", new TranslationLoader(translationsPattern, languages).load()); + + String source = Files.readString(STYLESHEET, StandardCharsets.UTF_8); + return new XsltTransformer(source, rendered, Paths.get("").toUri().toString()).transform(); + } +} diff --git a/src/test/java/com/materialidentity/schemaservice/QrSymbolTest.java b/src/test/java/com/materialidentity/schemaservice/QrSymbolTest.java new file mode 100644 index 00000000..71ce6e0c --- /dev/null +++ b/src/test/java/com/materialidentity/schemaservice/QrSymbolTest.java @@ -0,0 +1,126 @@ +// SPDX-License-Identifier: Apache-2.0 +package com.materialidentity.schemaservice; + +import com.google.zxing.common.BitMatrix; +import com.google.zxing.qrcode.decoder.Decoder; +import org.junit.jupiter.api.DisplayName; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.ValueSource; + +import java.nio.charset.StandardCharsets; +import java.util.Base64; +import java.util.regex.Matcher; +import java.util.regex.Pattern; + +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertFalse; +import static org.junit.jupiter.api.Assertions.assertThrows; +import static org.junit.jupiter.api.Assertions.assertTrue; + +/** + * The shared QR encoder, verified by decoding its output back — asserting that the encoder was + * called with the right string would only test that the code says what it says. + */ +class QrSymbolTest { + + private static final String URL = "https://dpp.s1seven.com/dpp/sms/H26-204517"; + + /** The modules an SVG's {@code M x yhWv1h-Wz} runs paint, without the quiet zone. */ + static BitMatrix modulesOf(String svg) { + int size = Integer.parseInt(match(svg, "data-modules=\"(\\d+)\"")); + String d = match(svg, " d=\"([^\"]*)\""); + BitMatrix bits = new BitMatrix(size, size); + Matcher run = Pattern.compile("M(\\d+) (\\d+)h(\\d+)v1h-\\d+z").matcher(d); + while (run.find()) { + int x = Integer.parseInt(run.group(1)) - QrSymbol.QUIET_ZONE; + int y = Integer.parseInt(run.group(2)) - QrSymbol.QUIET_ZONE; + for (int i = 0; i < Integer.parseInt(run.group(3)); i++) { + bits.set(x + i, y); + } + } + return bits; + } + + private static String match(String s, String regex) { + Matcher m = Pattern.compile(regex).matcher(s); + assertTrue(m.find(), "no " + regex); + return m.group(1); + } + + @ParameterizedTest(name = "{0}") + @ValueSource(strings = { + "https://dpp.s1seven.com/dpp/sms/H26-204517", + "https://id.s1seven.com/01/09506000134352/10/H24-118273", + "urn:epc:id:sgtin:4012345.000009.SN0001", + "0088:4012345000009", + "Chargen-Nr. 1607219/0001 — Prüfbescheinigung" + }) + @DisplayName("The matrix decodes back to exactly the encoded string") + void matrixRoundTrips(String data) throws Exception { + assertEquals(data, new Decoder().decode(QrSymbol.of(data).toBitMatrix()).getText()); + } + + @Test + @DisplayName("The SVG's own path data decodes back to the encoded string") + void svgRoundTrips() throws Exception { + String svg = QrSymbol.of(URL).toSvg(); + assertEquals(URL, new Decoder().decode(modulesOf(svg)).getText()); + assertTrue(svg.contains("" + URL + "")); + } + + @Test + @DisplayName("The data URI is the SVG, base64-encoded") + void dataUriIsTheSvg() { + QrSymbol symbol = QrSymbol.of(URL); + String uri = symbol.toSvgDataUri(); + assertTrue(uri.startsWith("data:image/svg+xml;base64,"), uri.substring(0, 40)); + String decoded = new String(Base64.getDecoder().decode(uri.substring(uri.indexOf(',') + 1)), + StandardCharsets.UTF_8); + assertEquals(symbol.toSvg(), decoded); + } + + @Test + @DisplayName("Markup in the encoded string is escaped in the attributes and the title") + void escapesMarkup() { + String svg = QrSymbol.of("a\"&c").toSvg(); + assertTrue(svg.contains("data-encoded=\"a"<b>&c\"")); + assertTrue(svg.contains("a"<b>&c")); + } + + @Test + @DisplayName("The symbol carries the ISO/IEC 18004 four-module quiet zone") + void quietZoneIsPresent() { + QrSymbol symbol = QrSymbol.of(URL); + assertEquals(4, QrSymbol.QUIET_ZONE); + assertEquals(symbol.modules().length + 2 * QrSymbol.QUIET_ZONE, symbol.moduleCount()); + assertTrue(symbol.pathData().startsWith("M" + QrSymbol.QUIET_ZONE + " " + QrSymbol.QUIET_ZONE), + "the finder pattern's first dark run starts one quiet zone in: " + symbol.pathData()); + } + + @Test + @DisplayName("Path data is emitted as an attribute value, never as markup") + void pathDataIsAttributeSafe() { + String path = QrSymbol.of(URL).pathData(); + assertFalse(path.isEmpty()); + for (char c : new char[] {'<', '>', '"', '&'}) { + assertFalse(path.indexOf(c) >= 0, "a markup character would have to be escaped past the serializer"); + } + } + + @Test + @DisplayName("A blank string is refused rather than encoded as an empty symbol") + void blankRefused() { + assertThrows(IllegalArgumentException.class, () -> QrSymbol.of(null)); + assertThrows(IllegalArgumentException.class, () -> QrSymbol.of(" ")); + } + + @Test + @DisplayName("A string too long for one symbol is refused with the length, not the whole string") + void tooLongRefused() { + String tooLong = "x".repeat(8000); + IllegalArgumentException e = assertThrows(IllegalArgumentException.class, () -> QrSymbol.of(tooLong)); + assertTrue(e.getMessage().contains("8000 characters"), e.getMessage()); + assertTrue(e.getMessage().length() < 200, "the message must not echo the oversized input"); + } +} diff --git a/test/fixtures/EN10168/v0.5.0/valid_certificate_11.json b/test/fixtures/EN10168/v0.5.0/valid_certificate_11.json new file mode 100644 index 00000000..1a296692 --- /dev/null +++ b/test/fixtures/EN10168/v0.5.0/valid_certificate_11.json @@ -0,0 +1,369 @@ +{ + "RefSchemaUrl": "https://schemas.materialidentity.org/en10168-schemas/v0.5.0/schema.json", + "Certificate": { + "CertificateLanguages": [ + "EN" + ], + "CommercialTransaction": { + "A01": { + "Name": "Steel Mill SE", + "Street": [ + "Stahlstrasse 1" + ], + "ZipCode": "4040", + "City": "Linz", + "Country": "AT" + }, + "A02": "Mill Certificate EN 10204 3.1", + "A03": "1866645/001", + "A04": "data:image/png;base64,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", + "A05": "Factory Production Control", + "A06": { + "Name": "Steel Trading AG", + "Street": [ + "Handelsgasse 1" + ], + "ZipCode": "10115", + "City": "Berlin", + "Country": "DE" + }, + "A07": "0334/2019/ZZS", + "A08": "958722", + "A09": "TR-12456", + "A97": "1", + "A98": "DN-1583836", + "A99": "AV-87682933", + "SupplementaryInformation": { + "A10": { + "Key": "Buyer Reference Number", + "Value": "BRN-1583836", + "Type": "string" + }, + "A11": { + "Key": "Reference Date", + "Value": "2018-10-23", + "Type": "date" + } + } + }, + "ProductDescription": { + "B01": "Seamleass Steel Tubes Hot Roild", + "B02": { + "SteelDesignation": [ + "S355J2H", + "P355NH/TC1", + "E355+N" + ], + "ProductNorm": [ + "EN 10219-1:2006" + ], + "MassNorm": [ + "EN 10220" + ], + "MaterialNorm": [ + "EN 10297-1:2003-06" + ] + }, + "B03": "Ausführung lt. EN 10219 Teil 1+2 /--/", + "B04": "normalized", + "B06": "SST 200x150x6", + "B07": [ + "7282841" + ], + "B08": 16, + "B09": { + "Form": "RectangularTube", + "Width": 200, + "Height": 150, + "WallThickness": 6.5, + "Unit": "mm" + }, + "B10": { + "Property": "Length", + "Value": 12000, + "Unit": "mm" + }, + "B11": { + "Property": "Corner radius", + "Value": 1.5, + "Unit": "mm" + }, + "B12": { + "Property": "Theoretical mass", + "Value": 5738.3, + "Unit": "kg" + }, + "B13": { + "Property": "Actual mass", + "Value": 5739.3, + "Unit": "kg" + }, + "SupplementaryInformation": { + "B20": { + "Key": "Digital Product Passport", + "Value": "https://dpp.example.org/dpp/steelmill/1607219-0001", + "Type": "url" + }, + "B21": { + "Key": "Digital Product Passport (QR code)", + "Value": "https://dpp.example.org/dpp/steelmill/1607219-0001", + "Type": "qr-code" + } + } + }, + "Inspection": [ + { + "C00": "Charge Chemical Analysis", + "ChemicalComposition": { + "C70": "Y", + "C71": { + "Actual": { + "Value": "0.1500" + }, + "Symbol": "C", + "Unit": "%" + }, + "C72": { + "Actual": { + "Value": "0.0050" + }, + "Symbol": "Si", + "Unit": "%" + }, + "C73": { + "Actual": { + "Value": "1.0000" + }, + "Symbol": "Mn", + "Unit": "%" + }, + "C74": { + "Actual": { + "Value": "0.0140" + }, + "Symbol": "P", + "Unit": "%" + }, + "C75": { + "Actual": { + "Value": "0.0070" + }, + "Symbol": "S", + "Unit": "%" + }, + "C76": { + "Actual": { + "Value": "0.0410" + }, + "Symbol": "Al", + "Unit": "%" + }, + "C77": { + "Actual": { + "Value": "0.0200" + }, + "Symbol": "Cr", + "Unit": "%" + }, + "C78": { + "Actual": { + "Value": "0.0090" + }, + "Symbol": "Ni", + "Unit": "%" + }, + "C79": { + "Actual": { + "Value": "0.0020" + }, + "Symbol": "Mo", + "Unit": "%" + }, + "SupplementaryInformation": { + "C116": { + "Key": "Sample Identifier", + "Value": "10001011/175508", + "Type": "string" + } + } + } + }, + { + "C00": "Charge TensileTest", + "C02": "0001 längs", + "C03": "-20 Celsius", + "TensileTest": { + "C11": { + "Property": "Streckgrenze ReH/RP0,2", + "Value": 377.12, + "Unit": "MPa" + }, + "C12": { + "Property": "Zugfestigkeit Rm", + "Value": 456.18, + "Unit": "MPa" + }, + "C13": { + "Property": "Bruchdehnung A5/A80", + "Value": 29.7, + "Unit": "%" + }, + "SupplementaryInformation": { + "C14": { + "Key": "Re/Rm", + "Value": "0.83", + "Type": "number" + }, + "C15": { + "Key": "Sample Identifier", + "Value": "10001011/175508", + "Type": "string" + } + } + } + }, + { + "C00": "Charge HardnessTest", + "C03": "-20 Celsius", + "HardnessTest": { + "C30": "Brunell", + "C31": [ + { + "Value": 71.3, + "Unit": "J" + }, + { + "Value": 84.2, + "Unit": "J" + }, + { + "Value": 85.2, + "Unit": "J" + } + ], + "C32": { + "Value": 80.3, + "Unit": "J", + "Minimum": 78.5, + "Maximum": 90.6 + } + } + }, + { + "C00": "Charge NotchedImpactTest", + "C03": "-20 Celsius", + "NotchedBarImpactTest": { + "C40": "0001 längs", + "C41": { + "Property": "Width", + "Value": 5, + "Unit": "mm" + }, + "C42": [ + { + "Value": 71.2, + "Unit": "J" + }, + { + "Value": 84.2, + "Unit": "J" + }, + { + "Value": 85.2, + "Unit": "J" + } + ], + "C43": { + "Value": 80.3, + "Unit": "J", + "Minimum": 78.5, + "Maximum": 90.6 + }, + "SupplementaryInformation": { + "C44": { + "Key": "Sample Identifier", + "Value": "10001011/175508", + "Type": "string" + } + } + } + } + ], + "OtherTests": { + "D01": "Marking", + "NonDestructiveTests": { + "D02": { + "Key": "Visual En 10219-1", + "Value": "100", + "Unit": "%", + "Interpretation": "Positive", + "Type": "number" + }, + "D03": { + "Key": "Non destructive test EN ISO 10893-2", + "Value": "100", + "Unit": "%", + "Interpretation": "Positive", + "Type": "number" + }, + "D04": { + "Key": "Dimensional Inspection EN 10219-2", + "Value": "1", + "Unit": "Lot", + "Interpretation": "Positive", + "Type": "number" + } + }, + "OtherProductTests": { + "D51": { + "Key": "Tensile flattening test", + "Value": "100", + "Unit": "%", + "Interpretation": "Positive", + "Type": "number" + } + } + }, + "Validation": { + "Z01": "We hereby certify, that the material described above has been tested and complies with the terms of the order. This certificate has been created by a data processing system and does not contain a personal signature but the name and the offical address of the appointet department.", + "Z02": "2018-10-23", + "Z03": { + "Name": "John D. Keller", + "Title": "Quality Manager" + }, + "Z04": { + "NotifiedBodyNumber": "0780", + "DoCYear": "19", + "DoCNumber": "0780-CPD-P012", + "CE_Image": "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAFoAAABACAMAAACtO5DNAAAAmVBMVEUAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAjHWqVAAAAMnRSTlMAzexb/E0FmyQJ+NLj3/Hn2qynhlOiuZJ8VzsqFQyf1caPjG5CMCEP9b6wgHVpHZRHHxEaALYAAAHuSURBVFjDxZjZcoMwDEUNYQ0QAoSUACFbsy9t9f8f14d2bIfgIjOj6X2+PgO2LEtiKh3tollH5tgyI5vh5Y2yJAgn1smMug1VZljANUJiHbsJQajD4d8N4MKjDxuTr+hGL28xgD66yvlvqtCLEEAfvdxysAr9mAMMQNth17JniwkD0M4GoA99BRiArtfQh3ZcGII+TKEP7STwInOdNG5zeWdqeTG0ZU3nqevmc+5pf/Mknx1Yr+qotSy4ln7Lkz07jIXPEFoGIGvs7jvC58mywmaNFGTljw7LlynvVeYgyXcZHHUfyVk+uxKd5cYgdDl2ekaSZeoxrOSr+6FIzbFErtHkmUTeKDyFsMQeQ2sllqWqCDLFCZZsyEcbqkjdCU/G8DJEOFcqTyDi2cGT98BVIDw2w2vLV4V+vydgGhJRtWP9+7HQIFcijyk/uu7x9J69i4ihlGlIZHd1Ni8G7Qfjb8vJQeRFT4PsWDyojRfd2pE/YRry4A+9/Zoiflt10CUGzRPIWQf9iUHzdJ7ooGeEaMIN+a9jJAw+witDcNEJ0hNdUqV8CggfMMpnl7JYICxxKAszynKStAimLN1JGw7SNom4uaNvSQkbacL2n2BoQTBqoRsQ0Y+16Idx9CNE+sEn/bhWDJnznyFzOHDI/A3NAGlA3stefgAAAABJRU5ErkJggg==" + }, + "SupplementaryInformation": { + "Z05": { + "Key": "Quality Department Tel.", + "Value": "+43 732 1000 8888", + "Type": "phone" + }, + "Z06": { + "Key": "Quality Department Fax", + "Value": "+43 732 1000 8889", + "Type": "phone" + }, + "Z07": { + "Key": "Quality Department Email", + "Value": "quality@steelmill.se", + "Type": "email" + }, + "Z08": { + "Key": "Ultra Green Steel", + "Value": "https://www.steelmill.com/ultragreensteel", + "Type": "url" + }, + "Z09": { + "Key": "Steel Mill Green Steel", + "Value": "data:image/png;base64,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", + "Type": "image" + } + } + } + } +} diff --git a/test/fixtures/EN10168/v0.5.0/valid_certificate_11.pdf b/test/fixtures/EN10168/v0.5.0/valid_certificate_11.pdf new file mode 100644 index 00000000..fd3c5728 Binary files /dev/null and b/test/fixtures/EN10168/v0.5.0/valid_certificate_11.pdf differ diff --git a/ui/package-lock.json b/ui/package-lock.json index bffff5e8..7c29dbf5 100644 --- a/ui/package-lock.json +++ b/ui/package-lock.json @@ -11245,24 +11245,10 @@ "postcss": "^8.2.14" } }, - "node_modules/postcss-nested/node_modules/postcss-selector-parser": { - "version": "6.1.4", - "resolved": "https://registry.npmjs.org/postcss-selector-parser/-/postcss-selector-parser-6.1.4.tgz", - "integrity": "sha512-bIoJLOmjCO1S9XdY/DcnR5hJxvrDir1PbGChrzXG3vw0/FOliy/fA3dmdhQ441kah4gKv+TwckGzex6wNS5cnQ==", - "license": "MIT", - "dependencies": { - "cssesc": "^3.0.0", - "util-deprecate": "^1.0.2" - }, - "engines": { - "node": ">=4" - } - }, "node_modules/postcss-selector-parser": { - "version": "7.1.4", - "resolved": "https://registry.npmjs.org/postcss-selector-parser/-/postcss-selector-parser-7.1.4.tgz", - "integrity": "sha512-HeP7D2wyhkR+XaK6v4W8oRF62Dsz4flyuczALJp61GckGm42u1saSSJ/0auvcBqxs3jMRFEcPK34At/0JBKdOg==", - "dev": true, + "version": "7.1.6", + "resolved": "https://registry.npmjs.org/postcss-selector-parser/-/postcss-selector-parser-7.1.6.tgz", + "integrity": "sha512-7qASPzhKF2l2KLboRZux8CCTRMdGiV08vWmyKzPz22qZ7ZjQBOeY7rNzNoCLSUiftJ7HUq0GERHmxw/t0dCdMw==", "license": "MIT", "dependencies": { "cssesc": "^3.0.0", @@ -12794,19 +12780,6 @@ "url": "https://github.com/sponsors/jonschlinkert" } }, - "node_modules/tailwindcss/node_modules/postcss-selector-parser": { - "version": "6.1.4", - "resolved": "https://registry.npmjs.org/postcss-selector-parser/-/postcss-selector-parser-6.1.4.tgz", - "integrity": "sha512-bIoJLOmjCO1S9XdY/DcnR5hJxvrDir1PbGChrzXG3vw0/FOliy/fA3dmdhQ441kah4gKv+TwckGzex6wNS5cnQ==", - "license": "MIT", - "dependencies": { - "cssesc": "^3.0.0", - "util-deprecate": "^1.0.2" - }, - "engines": { - "node": ">=4" - } - }, "node_modules/tailwindcss/node_modules/readdirp": { "version": "3.6.0", "resolved": "https://registry.npmjs.org/readdirp/-/readdirp-3.6.0.tgz", diff --git a/ui/package.json b/ui/package.json index 926cc89a..dd288769 100644 --- a/ui/package.json +++ b/ui/package.json @@ -42,7 +42,8 @@ "immutable": "5.1.9", "body-parser": "1.20.6", "nanoid": "3.3.18", - "brace-expansion": "2.1.4" + "brace-expansion": "2.1.4", + "postcss-selector-parser": "7.1.6" }, "devDependencies": { "@angular-devkit/build-angular": "19.2.23",