Base PGPainlessCLI on new sop-java module

* Rename pgpainless-sop -> pgpainless-cli
* Introduce sop-java (implementation-independent SOP API)
* Introduce sop-java-picocli (CLI frontend for sop-java)
* Introduce pgpainless-sop (implementation of sop-java using PGPainless)
* Rework pgpainless-cli (plugs pgpainless-sop into sop-java-picocli)

sop-java/src/test/java/sop/util/ByteArrayAndResultTest.java

@@ -0,0 +1,44 @@
+/*
+ * Copyright 2021 Paul Schaub.
+ *
+ * Licensed 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 sop.util;
+
+import static org.junit.jupiter.api.Assertions.assertArrayEquals;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+import java.nio.charset.StandardCharsets;
+import java.util.Collections;
+import java.util.List;
+
+import org.junit.jupiter.api.Test;
+import sop.ByteArrayAndResult;
+import sop.Verification;
+
+public class ByteArrayAndResultTest {
+
+    @Test
+    public void testCreationAndGetters() {
+        byte[] bytes = "Hello, World!\n".getBytes(StandardCharsets.UTF_8);
+        List<Verification> result = Collections.singletonList(
+                new Verification(UTCUtil.parseUTCDate("2019-10-24T23:48:29Z"),
+                        "C90E6D36200A1B922A1509E77618196529AE5FF8",
+                        "C4BC2DDB38CCE96485EBE9C2F20691179038E5C6")
+        );
+        ByteArrayAndResult<List<Verification>> bytesAndResult = new ByteArrayAndResult<>(bytes, result);
+
+        assertArrayEquals(bytes, bytesAndResult.getBytes());
+        assertEquals(result, bytesAndResult.getResult());
+    }
+}

sop-java/src/test/java/sop/util/HexUtilTest.java

@@ -0,0 +1,73 @@
+/*
+ * Copyright 2021 Paul Schaub.
+ *
+ * Licensed 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 sop.util;
+
+import static org.junit.jupiter.api.Assertions.assertArrayEquals;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+import java.nio.charset.Charset;
+
+import org.junit.jupiter.api.Test;
+
+/**
+ * Test using some test vectors from RFC4648.
+ *
+ * @see <a href="https://datatracker.ietf.org/doc/html/rfc4648#section-10">RFC-4648 §10: Test Vectors</a>
+ */
+public class HexUtilTest {
+
+    private static final Charset ASCII = Charset.forName("US-ASCII");
+
+    @Test
+    public void emptyHexEncodeTest() {
+        assertHexEquals("", "");
+    }
+
+    @Test
+    public void encodeF() {
+        assertHexEquals("66", "f");
+    }
+
+    @Test
+    public void encodeFo() {
+        assertHexEquals("666F", "fo");
+    }
+
+    @Test
+    public void encodeFoo() {
+        assertHexEquals("666F6F", "foo");
+    }
+
+    @Test
+    public void encodeFoob() {
+        assertHexEquals("666F6F62", "foob");
+    }
+
+    @Test
+    public void encodeFooba() {
+        assertHexEquals("666F6F6261", "fooba");
+    }
+
+    @Test
+    public void encodeFoobar() {
+        assertHexEquals("666F6F626172", "foobar");
+    }
+
+    private void assertHexEquals(String hex, String ascii) {
+        assertEquals(hex, HexUtil.bytesToHex(ascii.getBytes(ASCII)));
+        assertArrayEquals(ascii.getBytes(ASCII), HexUtil.hexToBytes(hex));
+    }
+}

sop-java/src/test/java/sop/util/OptionalTest.java

@@ -0,0 +1,89 @@
+/*
+ * Copyright 2021 Paul Schaub.
+ *
+ * Licensed 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 sop.util;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertNull;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+import org.junit.jupiter.api.Test;
+
+public class OptionalTest {
+
+    @Test
+    public void testEmpty() {
+        Optional<String> optional = new Optional<>();
+        assertEmpty(optional);
+    }
+
+    @Test
+    public void testArg() {
+        String string = "foo";
+        Optional<String> optional = new Optional<>(string);
+        assertFalse(optional.isEmpty());
+        assertTrue(optional.isPresent());
+        assertEquals(string, optional.get());
+    }
+
+    @Test
+    public void testOfEmpty() {
+        Optional<String> optional = Optional.ofEmpty();
+        assertEmpty(optional);
+    }
+
+    @Test
+    public void testNullArg() {
+        Optional<String> optional = new Optional<>(null);
+        assertEmpty(optional);
+    }
+
+    @Test
+    public void testOfWithNullArgThrows() {
+        assertThrows(NullPointerException.class, () -> Optional.of(null));
+    }
+
+    @Test
+    public void testOf() {
+        String string = "Hello, World!";
+        Optional<String> optional = Optional.of(string);
+        assertFalse(optional.isEmpty());
+        assertTrue(optional.isPresent());
+        assertEquals(string, optional.get());
+    }
+
+    @Test
+    public void testOfNullableWithNull() {
+        Optional<String> optional = Optional.ofNullable(null);
+        assertEmpty(optional);
+    }
+
+    @Test
+    public void testOfNullableWithArg() {
+        Optional<String> optional = Optional.ofNullable("bar");
+        assertEquals("bar", optional.get());
+        assertFalse(optional.isEmpty());
+        assertTrue(optional.isPresent());
+    }
+
+    private <T> void assertEmpty(Optional<T> optional) {
+        assertTrue(optional.isEmpty());
+        assertFalse(optional.isPresent());
+
+        assertNull(optional.get());
+    }
+}

sop-java/src/test/java/sop/util/ProxyOutputStreamTest.java

@@ -0,0 +1,51 @@
+/*
+ * Copyright 2021 Paul Schaub.
+ *
+ * Licensed 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 sop.util;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+
+import java.io.ByteArrayOutputStream;
+import java.io.IOException;
+import java.nio.charset.StandardCharsets;
+
+import org.junit.jupiter.api.Test;
+
+public class ProxyOutputStreamTest {
+
+    @Test
+    public void replaceOutputStreamThrowsNPEForNull() {
+        ProxyOutputStream proxy = new ProxyOutputStream();
+        assertThrows(NullPointerException.class, () -> proxy.replaceOutputStream(null));
+    }
+
+    @Test
+    public void testSwappingStreamPreservesWrittenBytes() throws IOException {
+        byte[] firstSection = "Foo\nBar\n".getBytes(StandardCharsets.UTF_8);
+        byte[] secondSection = "Baz\n".getBytes(StandardCharsets.UTF_8);
+
+        ProxyOutputStream proxy = new ProxyOutputStream();
+        proxy.write(firstSection);
+
+        ByteArrayOutputStream swappedStream = new ByteArrayOutputStream();
+        proxy.replaceOutputStream(swappedStream);
+
+        proxy.write(secondSection);
+        proxy.close();
+
+        assertEquals("Foo\nBar\nBaz\n", swappedStream.toString());
+    }
+}

sop-java/src/test/java/sop/util/ReadyTest.java

@@ -0,0 +1,41 @@
+/*
+ * Copyright 2021 Paul Schaub.
+ *
+ * Licensed 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 sop.util;
+
+import static org.junit.jupiter.api.Assertions.assertArrayEquals;
+
+import java.io.IOException;
+import java.io.OutputStream;
+import java.nio.charset.StandardCharsets;
+
+import org.junit.jupiter.api.Test;
+import sop.Ready;
+
+public class ReadyTest {
+
+    @Test
+    public void readyTest() throws IOException {
+        byte[] data = "Hello, World!\n".getBytes(StandardCharsets.UTF_8);
+        Ready ready = new Ready() {
+            @Override
+            public void writeTo(OutputStream outputStream) throws IOException {
+                outputStream.write(data);
+            }
+        };
+
+        assertArrayEquals(data, ready.getBytes());
+    }
+}

sop-java/src/test/java/sop/util/ReadyWithResultTest.java

@@ -0,0 +1,55 @@
+/*
+ * Copyright 2021 Paul Schaub.
+ *
+ * Licensed 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 sop.util;
+
+import static org.junit.jupiter.api.Assertions.assertArrayEquals;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+import java.io.IOException;
+import java.io.OutputStream;
+import java.nio.charset.StandardCharsets;
+import java.util.Collections;
+import java.util.List;
+
+import org.junit.jupiter.api.Test;
+import sop.ByteArrayAndResult;
+import sop.ReadyWithResult;
+import sop.Verification;
+import sop.exception.SOPGPException;
+
+public class ReadyWithResultTest {
+
+    @Test
+    public void testReadyWithResult() throws SOPGPException.NoSignature, IOException {
+        byte[] data = "Hello, World!\n".getBytes(StandardCharsets.UTF_8);
+        List<Verification> result = Collections.singletonList(
+                new Verification(UTCUtil.parseUTCDate("2019-10-24T23:48:29Z"),
+                        "C90E6D36200A1B922A1509E77618196529AE5FF8",
+                        "C4BC2DDB38CCE96485EBE9C2F20691179038E5C6")
+        );
+        ReadyWithResult<List<Verification>> readyWithResult = new ReadyWithResult<List<Verification>>() {
+            @Override
+            public List<Verification> writeTo(OutputStream outputStream) throws IOException, SOPGPException.NoSignature {
+                outputStream.write(data);
+                return result;
+            }
+        };
+
+        ByteArrayAndResult<List<Verification>> bytesAndResult = readyWithResult.toBytes();
+        assertArrayEquals(data, bytesAndResult.getBytes());
+        assertEquals(result, bytesAndResult.getResult());
+    }
+}

sop-java/src/test/java/sop/util/SessionKeyTest.java

@@ -0,0 +1,52 @@
+/*
+ * Copyright 2021 Paul Schaub.
+ *
+ * Licensed 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 sop.util;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertNotEquals;
+
+import org.junit.jupiter.api.Test;
+import sop.SessionKey;
+
+public class SessionKeyTest {
+
+    @Test
+    public void toStringTest() {
+        SessionKey sessionKey = new SessionKey((byte) 9, HexUtil.hexToBytes("FCA4BEAF687F48059CACC14FB019125CD57392BAB7037C707835925CBF9F7BCD"));
+        assertEquals("9:FCA4BEAF687F48059CACC14FB019125CD57392BAB7037C707835925CBF9F7BCD", sessionKey.toString());
+    }
+
+    @Test
+    public void equalsTest() {
+        SessionKey s1 = new SessionKey((byte) 9, HexUtil.hexToBytes("FCA4BEAF687F48059CACC14FB019125CD57392BAB7037C707835925CBF9F7BCD"));
+        SessionKey s2 = new SessionKey((byte) 9, HexUtil.hexToBytes("FCA4BEAF687F48059CACC14FB019125CD57392BAB7037C707835925CBF9F7BCD"));
+        SessionKey s3 = new SessionKey((byte) 4, HexUtil.hexToBytes("FCA4BEAF687F48059CACC14FB019125CD57392BAB7037C707835925CBF9F7BCD"));
+        SessionKey s4 = new SessionKey((byte) 9, HexUtil.hexToBytes("19125CD57392BAB7037C7078359FCA4BEAF687F4025CBF9F7BCD8059CACC14FB"));
+        SessionKey s5 = new SessionKey((byte) 4, HexUtil.hexToBytes("19125CD57392BAB7037C7078359FCA4BEAF687F4025CBF9F7BCD8059CACC14FB"));
+
+        assertEquals(s1, s1);
+        assertEquals(s1, s2);
+        assertEquals(s1.hashCode(), s2.hashCode());
+        assertNotEquals(s1, s3);
+        assertNotEquals(s1.hashCode(), s3.hashCode());
+        assertNotEquals(s1, s4);
+        assertNotEquals(s1.hashCode(), s4.hashCode());
+        assertNotEquals(s4, s5);
+        assertNotEquals(s4.hashCode(), s5.hashCode());
+        assertNotEquals(s1, null);
+        assertNotEquals(s1, "FCA4BEAF687F48059CACC14FB019125CD57392BAB7037C707835925CBF9F7BCD");
+    }
+}

sop-java/src/test/java/sop/util/UTCUtilTest.java

@@ -0,0 +1,59 @@
+/*
+ * Copyright 2021 Paul Schaub.
+ *
+ * Licensed 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 sop.util;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertNull;
+
+import java.util.Date;
+
+import org.junit.jupiter.api.Test;
+
+/**
+ * Test parsing some date examples from the stateless OpenPGP CLI spec.
+ *
+ * @see <a href="https://datatracker.ietf.org/doc/html/draft-dkg-openpgp-stateless-cli-01#section-4.1">OpenPGP Stateless CLI §4.1. Date</a>
+ */
+public class UTCUtilTest {
+
+    @Test
+    public void parseExample1() {
+        String timestamp = "2019-10-29T12:11:04+00:00";
+        Date date = UTCUtil.parseUTCDate(timestamp);
+        assertEquals("2019-10-29T12:11:04Z", UTCUtil.formatUTCDate(date));
+    }
+
+    @Test
+    public void parseExample2() {
+        String timestamp = "2019-10-24T23:48:29Z";
+        Date date = UTCUtil.parseUTCDate(timestamp);
+        assertEquals("2019-10-24T23:48:29Z", UTCUtil.formatUTCDate(date));
+    }
+
+    @Test
+    public void parseExample3() {
+        String timestamp = "20191029T121104Z";
+        Date date = UTCUtil.parseUTCDate(timestamp);
+        assertEquals("2019-10-29T12:11:04Z", UTCUtil.formatUTCDate(date));
+    }
+
+    @Test
+    public void invalidDateReturnsNull() {
+        String invalidTimestamp = "foobar";
+        Date expectNull = UTCUtil.parseUTCDate(invalidTimestamp);
+        assertNull(expectNull);
+    }
+}