2021-06-10 14:25:00 +02:00
|
|
|
/*
|
|
|
|
* 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 org.pgpainless.encryption_signing;
|
|
|
|
|
|
|
|
import static org.junit.jupiter.api.Assertions.assertEquals;
|
|
|
|
import static org.junit.jupiter.api.Assertions.assertNull;
|
|
|
|
import static org.junit.jupiter.api.Assertions.assertThrows;
|
2021-06-10 15:04:21 +02:00
|
|
|
import static org.junit.jupiter.api.Assertions.assertTrue;
|
2021-06-10 14:25:00 +02:00
|
|
|
|
2021-06-10 15:04:21 +02:00
|
|
|
import java.io.IOException;
|
|
|
|
import java.security.InvalidAlgorithmParameterException;
|
|
|
|
import java.security.NoSuchAlgorithmException;
|
|
|
|
import java.util.Arrays;
|
|
|
|
import java.util.Collections;
|
|
|
|
import java.util.Iterator;
|
|
|
|
import java.util.List;
|
|
|
|
import java.util.Set;
|
|
|
|
|
|
|
|
import org.bouncycastle.openpgp.PGPException;
|
|
|
|
import org.bouncycastle.openpgp.PGPPublicKey;
|
|
|
|
import org.bouncycastle.openpgp.PGPPublicKeyRing;
|
|
|
|
import org.bouncycastle.openpgp.PGPPublicKeyRingCollection;
|
|
|
|
import org.bouncycastle.openpgp.PGPSecretKeyRing;
|
|
|
|
import org.junit.jupiter.api.BeforeAll;
|
2021-06-10 14:25:00 +02:00
|
|
|
import org.junit.jupiter.api.Test;
|
2021-06-10 15:04:21 +02:00
|
|
|
import org.pgpainless.PGPainless;
|
|
|
|
import org.pgpainless.algorithm.KeyFlag;
|
2021-06-10 14:25:00 +02:00
|
|
|
import org.pgpainless.algorithm.SymmetricKeyAlgorithm;
|
2021-08-15 15:21:14 +02:00
|
|
|
import org.pgpainless.exception.KeyValidationError;
|
2021-06-10 15:04:21 +02:00
|
|
|
import org.pgpainless.key.SubkeyIdentifier;
|
|
|
|
import org.pgpainless.key.generation.KeySpec;
|
|
|
|
import org.pgpainless.key.generation.type.KeyType;
|
|
|
|
import org.pgpainless.key.generation.type.eddsa.EdDSACurve;
|
|
|
|
import org.pgpainless.key.generation.type.xdh.XDHSpec;
|
|
|
|
import org.pgpainless.key.util.KeyRingUtils;
|
|
|
|
import org.pgpainless.util.Passphrase;
|
2021-06-10 14:25:00 +02:00
|
|
|
|
|
|
|
public class EncryptionOptionsTest {
|
|
|
|
|
2021-06-10 15:04:21 +02:00
|
|
|
private static PGPSecretKeyRing secretKeys;
|
|
|
|
private static PGPPublicKeyRing publicKeys;
|
|
|
|
private static SubkeyIdentifier primaryKey;
|
|
|
|
private static SubkeyIdentifier encryptComms;
|
|
|
|
private static SubkeyIdentifier encryptStorage;
|
|
|
|
|
|
|
|
@BeforeAll
|
|
|
|
public static void generateKey() throws PGPException, InvalidAlgorithmParameterException, NoSuchAlgorithmException {
|
|
|
|
secretKeys = PGPainless.generateKeyRing()
|
2021-09-20 12:30:03 +02:00
|
|
|
.setPrimaryKey(KeySpec.getBuilder(KeyType.EDDSA(EdDSACurve._Ed25519), KeyFlag.CERTIFY_OTHER)
|
2021-09-13 19:20:19 +02:00
|
|
|
.build())
|
2021-09-20 12:30:03 +02:00
|
|
|
.addSubkey(KeySpec.getBuilder(KeyType.XDH(XDHSpec._X25519), KeyFlag.ENCRYPT_COMMS)
|
2021-09-13 19:20:19 +02:00
|
|
|
.build())
|
2021-09-20 12:30:03 +02:00
|
|
|
.addSubkey(KeySpec.getBuilder(KeyType.XDH(XDHSpec._X25519), KeyFlag.ENCRYPT_STORAGE)
|
2021-09-13 19:20:19 +02:00
|
|
|
.build())
|
2021-09-20 12:30:03 +02:00
|
|
|
.addUserId("test@pgpainless.org")
|
2021-06-10 15:04:21 +02:00
|
|
|
.build();
|
|
|
|
|
|
|
|
publicKeys = KeyRingUtils.publicKeyRingFrom(secretKeys);
|
|
|
|
|
|
|
|
Iterator<PGPPublicKey> iterator = publicKeys.iterator();
|
|
|
|
primaryKey = new SubkeyIdentifier(publicKeys, iterator.next().getKeyID());
|
|
|
|
encryptComms = new SubkeyIdentifier(publicKeys, iterator.next().getKeyID());
|
|
|
|
encryptStorage = new SubkeyIdentifier(publicKeys, iterator.next().getKeyID());
|
|
|
|
}
|
|
|
|
|
2021-06-10 14:25:00 +02:00
|
|
|
@Test
|
|
|
|
public void testOverrideEncryptionAlgorithmFailsForNULL() {
|
|
|
|
EncryptionOptions options = new EncryptionOptions();
|
|
|
|
assertNull(options.getEncryptionAlgorithmOverride());
|
|
|
|
|
|
|
|
assertThrows(IllegalArgumentException.class, () -> options.overrideEncryptionAlgorithm(SymmetricKeyAlgorithm.NULL));
|
|
|
|
|
|
|
|
assertNull(options.getEncryptionAlgorithmOverride());
|
|
|
|
}
|
|
|
|
|
|
|
|
@Test
|
|
|
|
public void testOverrideEncryptionOptions() {
|
|
|
|
EncryptionOptions options = new EncryptionOptions();
|
|
|
|
assertNull(options.getEncryptionAlgorithmOverride());
|
|
|
|
options.overrideEncryptionAlgorithm(SymmetricKeyAlgorithm.AES_128);
|
|
|
|
|
|
|
|
assertEquals(SymmetricKeyAlgorithm.AES_128, options.getEncryptionAlgorithmOverride());
|
|
|
|
}
|
2021-06-10 15:04:21 +02:00
|
|
|
|
|
|
|
@Test
|
|
|
|
public void testAddRecipients_EncryptCommunications() {
|
|
|
|
EncryptionOptions options = EncryptionOptions.encryptCommunications();
|
|
|
|
options.addRecipient(publicKeys);
|
|
|
|
|
|
|
|
Set<SubkeyIdentifier> encryptionKeys = options.getEncryptionKeyIdentifiers();
|
|
|
|
assertEquals(1, encryptionKeys.size());
|
|
|
|
assertEquals(encryptComms, encryptionKeys.iterator().next());
|
|
|
|
}
|
|
|
|
|
|
|
|
@Test
|
|
|
|
public void testAddRecipients_EncryptDataAtRest() {
|
|
|
|
EncryptionOptions options = EncryptionOptions.encryptDataAtRest();
|
|
|
|
options.addRecipient(publicKeys);
|
|
|
|
|
|
|
|
Set<SubkeyIdentifier> encryptionKeys = options.getEncryptionKeyIdentifiers();
|
|
|
|
assertEquals(1, encryptionKeys.size());
|
|
|
|
assertEquals(encryptStorage, encryptionKeys.iterator().next());
|
|
|
|
}
|
|
|
|
|
|
|
|
@Test
|
|
|
|
public void testAddRecipients_AllKeys() {
|
|
|
|
EncryptionOptions options = new EncryptionOptions();
|
|
|
|
options.addRecipient(publicKeys, EncryptionOptions.encryptToAllCapableSubkeys());
|
|
|
|
|
|
|
|
Set<SubkeyIdentifier> encryptionKeys = options.getEncryptionKeyIdentifiers();
|
|
|
|
|
|
|
|
assertEquals(2, encryptionKeys.size());
|
|
|
|
assertTrue(encryptionKeys.contains(encryptComms));
|
|
|
|
assertTrue(encryptionKeys.contains(encryptStorage));
|
|
|
|
}
|
|
|
|
|
|
|
|
@Test
|
|
|
|
public void testAddEmptyPassphraseFails() {
|
|
|
|
EncryptionOptions options = new EncryptionOptions();
|
|
|
|
assertThrows(IllegalArgumentException.class, () ->
|
|
|
|
options.addPassphrase(Passphrase.emptyPassphrase()));
|
|
|
|
}
|
|
|
|
|
|
|
|
@Test
|
|
|
|
public void testAddRecipient_KeyWithoutEncryptionKeyFails() throws PGPException, InvalidAlgorithmParameterException, NoSuchAlgorithmException {
|
|
|
|
EncryptionOptions options = new EncryptionOptions();
|
|
|
|
PGPSecretKeyRing secretKeys = PGPainless.generateKeyRing()
|
2021-09-20 12:30:03 +02:00
|
|
|
.setPrimaryKey(KeySpec.getBuilder(KeyType.EDDSA(EdDSACurve._Ed25519), KeyFlag.CERTIFY_OTHER, KeyFlag.SIGN_DATA))
|
|
|
|
.addUserId("test@pgpainless.org")
|
|
|
|
.build();
|
2021-06-10 15:04:21 +02:00
|
|
|
PGPPublicKeyRing publicKeys = KeyRingUtils.publicKeyRingFrom(secretKeys);
|
|
|
|
|
|
|
|
assertThrows(IllegalArgumentException.class, () -> options.addRecipient(publicKeys));
|
|
|
|
}
|
|
|
|
|
|
|
|
@Test
|
|
|
|
public void testEncryptionKeySelectionStrategyEmpty_ThrowsAssertionError() {
|
|
|
|
EncryptionOptions options = new EncryptionOptions();
|
|
|
|
|
|
|
|
assertThrows(IllegalArgumentException.class,
|
|
|
|
() -> options.addRecipient(publicKeys, new EncryptionOptions.EncryptionKeySelector() {
|
|
|
|
@Override
|
|
|
|
public List<PGPPublicKey> selectEncryptionSubkeys(List<PGPPublicKey> encryptionCapableKeys) {
|
|
|
|
return Collections.emptyList();
|
|
|
|
}
|
|
|
|
}));
|
|
|
|
|
|
|
|
assertThrows(IllegalArgumentException.class,
|
|
|
|
() -> options.addRecipient(publicKeys, "test@pgpainless.org", new EncryptionOptions.EncryptionKeySelector() {
|
|
|
|
@Override
|
|
|
|
public List<PGPPublicKey> selectEncryptionSubkeys(List<PGPPublicKey> encryptionCapableKeys) {
|
|
|
|
return Collections.emptyList();
|
|
|
|
}
|
|
|
|
}));
|
|
|
|
}
|
|
|
|
|
|
|
|
@Test
|
|
|
|
public void testAddRecipients_PGPPublicKeyRingCollection() throws PGPException, InvalidAlgorithmParameterException, NoSuchAlgorithmException, IOException {
|
|
|
|
PGPPublicKeyRing secondKeyRing = KeyRingUtils.publicKeyRingFrom(
|
|
|
|
PGPainless.generateKeyRing().modernKeyRing("other@pgpainless.org", null));
|
|
|
|
|
|
|
|
PGPPublicKeyRingCollection collection = new PGPPublicKeyRingCollection(
|
|
|
|
Arrays.asList(publicKeys, secondKeyRing));
|
|
|
|
|
|
|
|
EncryptionOptions options = new EncryptionOptions();
|
2021-08-04 16:38:17 +02:00
|
|
|
options.addRecipients(collection, EncryptionOptions.encryptToFirstSubkey());
|
2021-06-10 15:04:21 +02:00
|
|
|
assertEquals(2, options.getEncryptionKeyIdentifiers().size());
|
|
|
|
}
|
2021-06-10 15:18:31 +02:00
|
|
|
|
|
|
|
@Test
|
|
|
|
public void testAddRecipient_withValidUserId() {
|
|
|
|
EncryptionOptions options = new EncryptionOptions();
|
2021-08-04 16:38:17 +02:00
|
|
|
options.addRecipient(publicKeys, "test@pgpainless.org", EncryptionOptions.encryptToFirstSubkey());
|
2021-06-10 15:18:31 +02:00
|
|
|
|
|
|
|
assertEquals(1, options.getEncryptionMethods().size());
|
|
|
|
}
|
|
|
|
|
|
|
|
@Test
|
|
|
|
public void testAddRecipient_withInvalidUserId() {
|
|
|
|
EncryptionOptions options = new EncryptionOptions();
|
2021-08-15 15:21:14 +02:00
|
|
|
assertThrows(KeyValidationError.class, () -> options.addRecipient(publicKeys, "invalid@user.id"));
|
2021-06-10 15:18:31 +02:00
|
|
|
}
|
2021-06-10 14:25:00 +02:00
|
|
|
}
|