pgpainless / sop-java / #68

Committed 20 Jan 2026 09:05PM UTC coverage: 57.576% (-0.6%) from 58.151%

Build # #68

Build Type

push

other

Committed by

vanitasvitae

Commit Message

Fix missing parameter error in validate-userid command

Run Details

0 of 1 new or added line in 1 file covered. (0.0%)

159 existing lines in 5 files now uncovered.

2109 of 3663 relevant lines covered (57.58%)

0.58 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

27.69

/sop-java-testfixtures/src/main/java/sop/testsuite/operation/ChangeKeyPasswordTest.java

// SPDX-FileCopyrightText: 2023 Paul Schaub <vanitasvitae@fsfe.org>
//
// SPDX-License-Identifier: Apache-2.0

package sop.testsuite.operation;

import org.junit.jupiter.api.condition.EnabledIf;
import org.junit.jupiter.params.ParameterizedTest;
import org.junit.jupiter.params.provider.Arguments;
import org.junit.jupiter.params.provider.MethodSource;
import sop.SOP;
import sop.exception.SOPGPException;
import sop.testsuite.JUtils;
import sop.testsuite.TestData;
import sop.util.UTF8Util;

import java.io.IOException;
import java.nio.charset.StandardCharsets;
import java.util.stream.Stream;

import static org.junit.jupiter.api.Assertions.assertArrayEquals;
import static org.junit.jupiter.api.Assertions.assertFalse;
import static org.junit.jupiter.api.Assertions.assertThrows;

@EnabledIf("sop.testsuite.operation.AbstractSOPTest#hasBackends")
public class ChangeKeyPasswordTest extends AbstractSOPTest {

    static Stream<Arguments> provideInstances() {
        return AbstractSOPTest.provideBackends();
    }

    @ParameterizedTest
    @MethodSource("provideInstances")
    public void changePasswordFromUnprotectedToProtected(SOP sop) throws IOException {
        byte[] unprotectedKey = assumeSupported(sop::generateKey).generate().getBytes();
        byte[] password = "sw0rdf1sh".getBytes(UTF8Util.UTF8);
        byte[] protectedKey = assumeSupported(sop::changeKeyPassword).newKeyPassphrase(password).keys(unprotectedKey).getBytes();

        assumeSupported(sop::sign).withKeyPassword(password).key(protectedKey).data("Test123".getBytes(StandardCharsets.UTF_8));
    }

    @ParameterizedTest
    @MethodSource("provideInstances")
    public void changePasswordFromUnprotectedToUnprotected(SOP sop) throws IOException {
        byte[] unprotectedKey = assumeSupported(sop::generateKey).noArmor().generate().getBytes();
        byte[] stillUnprotectedKey = assumeSupported(sop::changeKeyPassword).noArmor().keys(unprotectedKey).getBytes();

        assertArrayEquals(unprotectedKey, stillUnprotectedKey);
    }

    @ParameterizedTest
    @MethodSource("provideInstances")
    public void changePasswordFromProtectedToUnprotected(SOP sop) throws IOException {
        byte[] password = "sw0rdf1sh".getBytes(UTF8Util.UTF8);
        byte[] protectedKey = assumeSupported(sop::generateKey).withKeyPassword(password).generate().getBytes();
        byte[] unprotectedKey = assumeSupported(sop::changeKeyPassword)
                .oldKeyPassphrase(password)
                .keys(protectedKey).getBytes();

        assumeSupported(sop::sign).key(unprotectedKey).data("Test123".getBytes(StandardCharsets.UTF_8));
    }

    @ParameterizedTest
    @MethodSource("provideInstances")
    public void changePasswordFromProtectedToDifferentProtected(SOP sop) throws IOException {
        byte[] oldPassword = "sw0rdf1sh".getBytes(UTF8Util.UTF8);
        byte[] newPassword = "0r4ng3".getBytes(UTF8Util.UTF8);
        byte[] protectedKey = assumeSupported(sop::generateKey).withKeyPassword(oldPassword).generate().getBytes();
        byte[] reprotectedKey = assumeSupported(sop::changeKeyPassword)
                .oldKeyPassphrase(oldPassword)
                .newKeyPassphrase(newPassword)
                .keys(protectedKey).getBytes();

        assumeSupported(sop::sign).key(reprotectedKey).withKeyPassword(newPassword).data("Test123".getBytes(StandardCharsets.UTF_8));
    }


    @ParameterizedTest
    @MethodSource("provideInstances")
    public void changePasswordWithWrongOldPasswordFails(SOP sop) throws IOException {
        byte[] oldPassword = "sw0rdf1sh".getBytes(UTF8Util.UTF8);
        byte[] newPassword = "monkey123".getBytes(UTF8Util.UTF8);
        byte[] wrongPassword = "0r4ng3".getBytes(UTF8Util.UTF8);

        byte[] protectedKey = assumeSupported(sop::generateKey).withKeyPassword(oldPassword).generate().getBytes();
        assertThrows(SOPGPException.KeyIsProtected.class, () -> assumeSupported(sop::changeKeyPassword)
                .oldKeyPassphrase(wrongPassword)
                .newKeyPassphrase(newPassword)
                .keys(protectedKey).getBytes());
    }

    @ParameterizedTest
    @MethodSource("provideInstances")
    public void changePasswordWithMissingOldPasswordFails(SOP sop) throws IOException {
        byte[] oldPassword = "sw0rdf1sh".getBytes(UTF8Util.UTF8);
        byte[] newPassword = "monkey123".getBytes(UTF8Util.UTF8);

        byte[] protectedKey = assumeSupported(sop::generateKey).withKeyPassword(oldPassword).generate().getBytes();
        assertThrows(SOPGPException.KeyIsProtected.class, () -> assumeSupported(sop::changeKeyPassword)
                .newKeyPassphrase(newPassword) // do not pass in old password -> expect KeyIsProtected error
                .keys(protectedKey).getBytes());
    }

    @ParameterizedTest
    @MethodSource("provideInstances")
    public void nonUtf8PasswordsFail(SOP sop) {
        assertThrows(SOPGPException.PasswordNotHumanReadable.class, () ->
                assumeSupported(sop::changeKeyPassword).oldKeyPassphrase(new byte[] {(byte) 0xff, (byte) 0xfe}));
        assertThrows(SOPGPException.PasswordNotHumanReadable.class, () ->
                assumeSupported(sop::changeKeyPassword).newKeyPassphrase(new byte[] {(byte) 0xff, (byte) 0xfe}));

    }

    @ParameterizedTest
    @MethodSource("provideInstances")
    public void testNoArmor(SOP sop) throws IOException {
        byte[] oldPassword = "sw0rdf1sh".getBytes(UTF8Util.UTF8);
        byte[] newPassword = "0r4ng3".getBytes(UTF8Util.UTF8);
        byte[] protectedKey = assumeSupported(sop::generateKey).withKeyPassword(oldPassword).generate().getBytes();

        byte[] armored = assumeSupported(sop::changeKeyPassword)
                .oldKeyPassphrase(oldPassword)
                .newKeyPassphrase(newPassword)
                .keys(protectedKey)
                .getBytes();
        JUtils.assertArrayStartsWith(armored, TestData.BEGIN_PGP_PRIVATE_KEY_BLOCK);

        byte[] unarmored = assumeSupported(sop::changeKeyPassword)
                .noArmor()
                .oldKeyPassphrase(oldPassword)
                .newKeyPassphrase(newPassword)
                .keys(protectedKey)
                .getBytes();
        assertFalse(JUtils.arrayStartsWith(unarmored, TestData.BEGIN_PGP_PRIVATE_KEY_BLOCK));
    }
}

1	// SPDX-FileCopyrightText: 2023 Paul Schaub <vanitasvitae@fsfe.org>
2	//
3	// SPDX-License-Identifier: Apache-2.0
4
5	package sop.testsuite.operation;
6
7	import org.junit.jupiter.api.condition.EnabledIf;
8	import org.junit.jupiter.params.ParameterizedTest;
9	import org.junit.jupiter.params.provider.Arguments;
10	import org.junit.jupiter.params.provider.MethodSource;
11	import sop.SOP;
12	import sop.exception.SOPGPException;
13	import sop.testsuite.JUtils;
14	import sop.testsuite.TestData;
15	import sop.util.UTF8Util;
16
17	import java.io.IOException;
18	import java.nio.charset.StandardCharsets;
19	import java.util.stream.Stream;
20
21	import static org.junit.jupiter.api.Assertions.assertArrayEquals;
22	import static org.junit.jupiter.api.Assertions.assertFalse;
23	import static org.junit.jupiter.api.Assertions.assertThrows;
24
25	@EnabledIf("sop.testsuite.operation.AbstractSOPTest#hasBackends")
26	public class ChangeKeyPasswordTest extends AbstractSOPTest {	1✔
27
28	static Stream<Arguments> provideInstances() {
29	return AbstractSOPTest.provideBackends();	1✔
30	}
31
32	@ParameterizedTest
33	@MethodSource("provideInstances")
34	public void changePasswordFromUnprotectedToProtected(SOP sop) throws IOException {
35	byte[] unprotectedKey = assumeSupported(sop::generateKey).generate().getBytes();	1✔
36	byte[] password = "sw0rdf1sh".getBytes(UTF8Util.UTF8);	1✔
37	byte[] protectedKey = assumeSupported(sop::changeKeyPassword).newKeyPassphrase(password).keys(unprotectedKey).getBytes();	×
38
39	assumeSupported(sop::sign).withKeyPassword(password).key(protectedKey).data("Test123".getBytes(StandardCharsets.UTF_8));	×
40	}	×
41
42	@ParameterizedTest
43	@MethodSource("provideInstances")
44	public void changePasswordFromUnprotectedToUnprotected(SOP sop) throws IOException {
45	byte[] unprotectedKey = assumeSupported(sop::generateKey).noArmor().generate().getBytes();	1✔
46	byte[] stillUnprotectedKey = assumeSupported(sop::changeKeyPassword).noArmor().keys(unprotectedKey).getBytes();	×
47
48	assertArrayEquals(unprotectedKey, stillUnprotectedKey);	×
49	}	×
50
51	@ParameterizedTest
52	@MethodSource("provideInstances")
53	public void changePasswordFromProtectedToUnprotected(SOP sop) throws IOException {
54	byte[] password = "sw0rdf1sh".getBytes(UTF8Util.UTF8);	1✔
55	byte[] protectedKey = assumeSupported(sop::generateKey).withKeyPassword(password).generate().getBytes();	×
56	byte[] unprotectedKey = assumeSupported(sop::changeKeyPassword)	×
57	.oldKeyPassphrase(password)	×
58	.keys(protectedKey).getBytes();	×
59
60	assumeSupported(sop::sign).key(unprotectedKey).data("Test123".getBytes(StandardCharsets.UTF_8));	×
61	}	×
62
63	@ParameterizedTest
64	@MethodSource("provideInstances")
65	public void changePasswordFromProtectedToDifferentProtected(SOP sop) throws IOException {
66	byte[] oldPassword = "sw0rdf1sh".getBytes(UTF8Util.UTF8);	1✔
67	byte[] newPassword = "0r4ng3".getBytes(UTF8Util.UTF8);	1✔
68	byte[] protectedKey = assumeSupported(sop::generateKey).withKeyPassword(oldPassword).generate().getBytes();	×
69	byte[] reprotectedKey = assumeSupported(sop::changeKeyPassword)	×
70	.oldKeyPassphrase(oldPassword)	×
71	.newKeyPassphrase(newPassword)	×
72	.keys(protectedKey).getBytes();	×
73
74	assumeSupported(sop::sign).key(reprotectedKey).withKeyPassword(newPassword).data("Test123".getBytes(StandardCharsets.UTF_8));	×
75	}	×
76
77
78	@ParameterizedTest
79	@MethodSource("provideInstances")
80	public void changePasswordWithWrongOldPasswordFails(SOP sop) throws IOException {
81	byte[] oldPassword = "sw0rdf1sh".getBytes(UTF8Util.UTF8);	1✔
82	byte[] newPassword = "monkey123".getBytes(UTF8Util.UTF8);	1✔
83	byte[] wrongPassword = "0r4ng3".getBytes(UTF8Util.UTF8);	1✔
84
85	byte[] protectedKey = assumeSupported(sop::generateKey).withKeyPassword(oldPassword).generate().getBytes();	×
86	assertThrows(SOPGPException.KeyIsProtected.class, () -> assumeSupported(sop::changeKeyPassword)	×
87	.oldKeyPassphrase(wrongPassword)	×
88	.newKeyPassphrase(newPassword)	×
89	.keys(protectedKey).getBytes());	×
90	}	×
91
92	@ParameterizedTest
93	@MethodSource("provideInstances")
94	public void changePasswordWithMissingOldPasswordFails(SOP sop) throws IOException {
95	byte[] oldPassword = "sw0rdf1sh".getBytes(UTF8Util.UTF8);	1✔
96	byte[] newPassword = "monkey123".getBytes(UTF8Util.UTF8);	1✔
97
98	byte[] protectedKey = assumeSupported(sop::generateKey).withKeyPassword(oldPassword).generate().getBytes();	×
UNCOV 99	assertThrows(SOPGPException.KeyIsProtected.class, () -> assumeSupported(sop::changeKeyPassword)	×
UNCOV 100	.newKeyPassphrase(newPassword) // do not pass in old password -> expect KeyIsProtected error	×
UNCOV 101	.keys(protectedKey).getBytes());	×
UNCOV 102	}	×
103
104	@ParameterizedTest
105	@MethodSource("provideInstances")
106	public void nonUtf8PasswordsFail(SOP sop) {
107	assertThrows(SOPGPException.PasswordNotHumanReadable.class, () ->	1✔
UNCOV 108	assumeSupported(sop::changeKeyPassword).oldKeyPassphrase(new byte[] {(byte) 0xff, (byte) 0xfe}));	×
109	assertThrows(SOPGPException.PasswordNotHumanReadable.class, () ->	1✔
110	assumeSupported(sop::changeKeyPassword).newKeyPassphrase(new byte[] {(byte) 0xff, (byte) 0xfe}));	×
111
112	}	1✔
113
114	@ParameterizedTest
115	@MethodSource("provideInstances")
116	public void testNoArmor(SOP sop) throws IOException {
117	byte[] oldPassword = "sw0rdf1sh".getBytes(UTF8Util.UTF8);	1✔
118	byte[] newPassword = "0r4ng3".getBytes(UTF8Util.UTF8);	1✔
119	byte[] protectedKey = assumeSupported(sop::generateKey).withKeyPassword(oldPassword).generate().getBytes();	×
120
121	byte[] armored = assumeSupported(sop::changeKeyPassword)	×
122	.oldKeyPassphrase(oldPassword)	×
123	.newKeyPassphrase(newPassword)	×
UNCOV 124	.keys(protectedKey)	×
UNCOV 125	.getBytes();	×
UNCOV 126	JUtils.assertArrayStartsWith(armored, TestData.BEGIN_PGP_PRIVATE_KEY_BLOCK);	×
127
UNCOV 128	byte[] unarmored = assumeSupported(sop::changeKeyPassword)	×
UNCOV 129	.noArmor()	×
UNCOV 130	.oldKeyPassphrase(oldPassword)	×
UNCOV 131	.newKeyPassphrase(newPassword)	×
UNCOV 132	.keys(protectedKey)	×
UNCOV 133	.getBytes();	×
UNCOV 134	assertFalse(JUtils.arrayStartsWith(unarmored, TestData.BEGIN_PGP_PRIVATE_KEY_BLOCK));	×
UNCOV 135	}	×
136	}

pgpainless / sop-java / #68

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous