PGPainless/pgpainless
PGPainless/pgpainless
1
0
Fork 0
mirror of https://github.com/pgpainless/pgpainless.git synced 2024-11-26 22:32:07 +01:00
Code Issues Releases Wiki Activity

Fix API for accessing preferred algorithms

Browse source
This commit is contained in:
Paul Schaub 2021-11-15 13:02:26 +01:00
parent 8a40cdeefb
commit 19b1a0238d
Signed by: vanitasvitae
GPG key ID: 62BEE9264BF17311
3 changed files with 52 additions and 60 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

6
pgpainless-core/src/main/java/org/pgpainless/encryption_signing/SigningOptions.java
View file

@ -165,7 +165,8 @@ public final class SigningOptions {
for (PGPPublicKey signingPubKey : signingPubKeys) { for (PGPPublicKey signingPubKey : signingPubKeys) {
PGPSecretKey signingSecKey = secretKey.getSecretKey(signingPubKey.getKeyID()); PGPSecretKey signingSecKey = secretKey.getSecretKey(signingPubKey.getKeyID());
PGPPrivateKey signingSubkey = UnlockSecretKey.unlockSecretKey(signingSecKey, secretKeyDecryptor); PGPPrivateKey signingSubkey = UnlockSecretKey.unlockSecretKey(signingSecKey, secretKeyDecryptor);
Set<HashAlgorithm> hashAlgorithms = keyRingInfo.getPreferredHashAlgorithms(userId, signingPubKey.getKeyID()); Set<HashAlgorithm> hashAlgorithms = userId != null ? keyRingInfo.getPreferredHashAlgorithms(userId)
: keyRingInfo.getPreferredHashAlgorithms(signingPubKey.getKeyID());
HashAlgorithm hashAlgorithm = negotiateHashAlgorithm(hashAlgorithms, PGPainless.getPolicy()); HashAlgorithm hashAlgorithm = negotiateHashAlgorithm(hashAlgorithms, PGPainless.getPolicy());
addSigningMethod(secretKey, signingSubkey, hashAlgorithm, signatureType, false); addSigningMethod(secretKey, signingSubkey, hashAlgorithm, signatureType, false);
} }
@ -244,7 +245,8 @@ public final class SigningOptions {
for (PGPPublicKey signingPubKey : signingPubKeys) { for (PGPPublicKey signingPubKey : signingPubKeys) {
PGPSecretKey signingSecKey = secretKey.getSecretKey(signingPubKey.getKeyID()); PGPSecretKey signingSecKey = secretKey.getSecretKey(signingPubKey.getKeyID());
PGPPrivateKey signingSubkey = signingSecKey.extractPrivateKey(secretKeyDecryptor.getDecryptor(signingPubKey.getKeyID())); PGPPrivateKey signingSubkey = signingSecKey.extractPrivateKey(secretKeyDecryptor.getDecryptor(signingPubKey.getKeyID()));
Set<HashAlgorithm> hashAlgorithms = keyRingInfo.getPreferredHashAlgorithms(userId, signingPubKey.getKeyID()); Set<HashAlgorithm> hashAlgorithms = userId != null ? keyRingInfo.getPreferredHashAlgorithms(userId)
: keyRingInfo.getPreferredHashAlgorithms(signingPubKey.getKeyID());
HashAlgorithm hashAlgorithm = negotiateHashAlgorithm(hashAlgorithms, PGPainless.getPolicy()); HashAlgorithm hashAlgorithm = negotiateHashAlgorithm(hashAlgorithms, PGPainless.getPolicy());
addSigningMethod(secretKey, signingSubkey, hashAlgorithm, signatureType, true); addSigningMethod(secretKey, signingSubkey, hashAlgorithm, signatureType, true);
} }

64
pgpainless-core/src/main/java/org/pgpainless/key/info/KeyRingInfo.java
View file

@ -18,7 +18,6 @@ import java.util.NoSuchElementException;
import java.util.Set; import java.util.Set;
import java.util.regex.Matcher; import java.util.regex.Matcher;
import java.util.regex.Pattern; import java.util.regex.Pattern;
import javax.annotation.Nonnull; import javax.annotation.Nonnull;
import javax.annotation.Nullable; import javax.annotation.Nullable;
@ -846,43 +845,40 @@ public class KeyRingInfo {
return signingKeys; return signingKeys;
} }
/** public Set<HashAlgorithm> getPreferredHashAlgorithms() {
* Return the (sorted) set of preferred hash algorithms of the given key. return getPreferredHashAlgorithms(getPrimaryUserId());
*
* @param userId user-id. If this is non-null, the hash algorithms are being extracted from the user-id
* certification signature first.
* @param keyID if of the key in question
* @return hash algorithm preferences
*/
public Set<HashAlgorithm> getPreferredHashAlgorithms(@Nullable String userId, long keyID) {
KeyAccessor keyAccessor = getKeyAccessor(userId, keyID);
return keyAccessor.getPreferredHashAlgorithms();
} }
/** public Set<HashAlgorithm> getPreferredHashAlgorithms(String userId) {
* Return the (sorted) set of preferred symmetric encryption algorithms of the given key. return getKeyAccessor(userId, getKeyId()).getPreferredHashAlgorithms();
*
* @param userId user-id. If this is non-null, the symmetric encryption algorithms are being
* extracted from the user-id certification signature first.
* @param keyId if of the key in question
* @return symmetric encryption algorithm preferences
*/
public Set<SymmetricKeyAlgorithm> getPreferredSymmetricKeyAlgorithms(@Nullable String userId, long keyId) {
KeyAccessor keyAccessor = getKeyAccessor(userId, keyId);
return keyAccessor.getPreferredSymmetricKeyAlgorithms();
} }
/** public Set<HashAlgorithm> getPreferredHashAlgorithms(long keyId) {
* Return the (sorted) set of preferred compression algorithms of the given key. return getKeyAccessor(null, keyId).getPreferredHashAlgorithms();
* }
* @param userId user-id. If this is non-null, the compression algorithms are being extracted from the user-id
* certification signature first. public Set<SymmetricKeyAlgorithm> getPreferredSymmetricKeyAlgorithms() {
* @param keyId if of the key in question return getPreferredSymmetricKeyAlgorithms(getPrimaryUserId());
* @return compression algorithm preferences }
*/
public Set<CompressionAlgorithm> getPreferredCompressionAlgorithms(@Nullable String userId, long keyId) { public Set<SymmetricKeyAlgorithm> getPreferredSymmetricKeyAlgorithms(String userId) {
KeyAccessor keyAccessor = getKeyAccessor(userId, keyId); return getKeyAccessor(userId, getKeyId()).getPreferredSymmetricKeyAlgorithms();
return keyAccessor.getPreferredCompressionAlgorithms(); }
public Set<SymmetricKeyAlgorithm> getPreferredSymmetricKeyAlgorithms(long keyId) {
return getKeyAccessor(null, keyId).getPreferredSymmetricKeyAlgorithms();
}
public Set<CompressionAlgorithm> getPreferredCompressionAlgorithms() {
return getPreferredCompressionAlgorithms(getPrimaryUserId());
}
public Set<CompressionAlgorithm> getPreferredCompressionAlgorithms(String userId) {
return getKeyAccessor(userId, getKeyId()).getPreferredCompressionAlgorithms();
}
public Set<CompressionAlgorithm> getPreferredCompressionAlgorithms(long keyId) {
return getKeyAccessor(null, keyId).getPreferredCompressionAlgorithms();
} }
private KeyAccessor getKeyAccessor(@Nullable String userId, long keyID) { private KeyAccessor getKeyAccessor(@Nullable String userId, long keyID) {

42
pgpainless-core/src/test/java/org/pgpainless/key/info/KeyRingInfoTest.java
View file

@ -605,40 +605,34 @@ public class KeyRingInfoTest {
KeyRingInfo info = PGPainless.inspectKeyRing(secretKeys); KeyRingInfo info = PGPainless.inspectKeyRing(secretKeys);
// Bob is an invalid userId // Bob is an invalid userId
assertThrows(IllegalArgumentException.class, () -> info.getPreferredSymmetricKeyAlgorithms("Bob", 0)); assertThrows(IllegalArgumentException.class, () -> info.getPreferredSymmetricKeyAlgorithms("Bob"));
assertThrows(IllegalArgumentException.class, () -> info.getPreferredSymmetricKeyAlgorithms("Bob", pkid));
// 123 is an invalid keyid // 123 is an invalid keyid
assertThrows(IllegalArgumentException.class, () -> info.getPreferredSymmetricKeyAlgorithms(null, 123L)); assertThrows(IllegalArgumentException.class, () -> info.getPreferredSymmetricKeyAlgorithms(123L));
assertThrows(IllegalArgumentException.class, () -> info.getPreferredSymmetricKeyAlgorithms("Alice", 123L));
assertEquals(preferredHashAlgorithms, info.getPreferredHashAlgorithms("Alice", pkid)); assertEquals(preferredHashAlgorithms, info.getPreferredHashAlgorithms("Alice"));
assertEquals(preferredHashAlgorithms, info.getPreferredHashAlgorithms(null, pkid)); assertEquals(preferredHashAlgorithms, info.getPreferredHashAlgorithms(pkid));
assertEquals(preferredHashAlgorithms, info.getPreferredHashAlgorithms(null, skid1)); assertEquals(preferredHashAlgorithms, info.getPreferredHashAlgorithms(skid1));
assertEquals(preferredHashAlgorithms, info.getPreferredHashAlgorithms(null, skid2)); assertEquals(preferredHashAlgorithms, info.getPreferredHashAlgorithms(skid2));
// Bob is an invalid userId // Bob is an invalid userId
assertThrows(IllegalArgumentException.class, () -> info.getPreferredCompressionAlgorithms("Bob", 0)); assertThrows(IllegalArgumentException.class, () -> info.getPreferredCompressionAlgorithms("Bob"));
assertThrows(IllegalArgumentException.class, () -> info.getPreferredCompressionAlgorithms("Bob", pkid));
// 123 is an invalid keyid // 123 is an invalid keyid
assertThrows(IllegalArgumentException.class, () -> info.getPreferredCompressionAlgorithms(null, 123L)); assertThrows(IllegalArgumentException.class, () -> info.getPreferredCompressionAlgorithms(123L));
assertThrows(IllegalArgumentException.class, () -> info.getPreferredCompressionAlgorithms("Alice", 123L));
assertEquals(preferredCompressionAlgorithms, info.getPreferredCompressionAlgorithms("Alice", pkid)); assertEquals(preferredCompressionAlgorithms, info.getPreferredCompressionAlgorithms("Alice"));
assertEquals(preferredCompressionAlgorithms, info.getPreferredCompressionAlgorithms(null, pkid)); assertEquals(preferredCompressionAlgorithms, info.getPreferredCompressionAlgorithms(pkid));
assertEquals(preferredCompressionAlgorithms, info.getPreferredCompressionAlgorithms(null, skid1)); assertEquals(preferredCompressionAlgorithms, info.getPreferredCompressionAlgorithms(skid1));
assertEquals(preferredCompressionAlgorithms, info.getPreferredCompressionAlgorithms(null, skid2)); assertEquals(preferredCompressionAlgorithms, info.getPreferredCompressionAlgorithms(skid2));
// Bob is an invalid userId // Bob is an invalid userId
assertThrows(IllegalArgumentException.class, () -> info.getPreferredSymmetricKeyAlgorithms("Bob", 0)); assertThrows(IllegalArgumentException.class, () -> info.getPreferredSymmetricKeyAlgorithms("Bob"));
assertThrows(IllegalArgumentException.class, () -> info.getPreferredSymmetricKeyAlgorithms("Bob", pkid));
// 123 is an invalid keyid // 123 is an invalid keyid
assertThrows(IllegalArgumentException.class, () -> info.getPreferredSymmetricKeyAlgorithms(null, 123L)); assertThrows(IllegalArgumentException.class, () -> info.getPreferredSymmetricKeyAlgorithms(123L));
assertThrows(IllegalArgumentException.class, () -> info.getPreferredSymmetricKeyAlgorithms("Alice", 123L));
assertEquals(preferredSymmetricAlgorithms, info.getPreferredSymmetricKeyAlgorithms("Alice", pkid)); assertEquals(preferredSymmetricAlgorithms, info.getPreferredSymmetricKeyAlgorithms("Alice"));
assertEquals(preferredSymmetricAlgorithms, info.getPreferredSymmetricKeyAlgorithms(null, pkid)); assertEquals(preferredSymmetricAlgorithms, info.getPreferredSymmetricKeyAlgorithms(pkid));
assertEquals(preferredSymmetricAlgorithms, info.getPreferredSymmetricKeyAlgorithms(null, skid1)); assertEquals(preferredSymmetricAlgorithms, info.getPreferredSymmetricKeyAlgorithms(skid1));
assertEquals(preferredSymmetricAlgorithms, info.getPreferredSymmetricKeyAlgorithms(null, skid2)); assertEquals(preferredSymmetricAlgorithms, info.getPreferredSymmetricKeyAlgorithms(skid2));
} }