org.bouncycastle.openpgp.api

Class OpenPGPDefaultPolicy

java.lang.Object

org.bouncycastle.openpgp.api.OpenPGPDefaultPolicy

All Implemented Interfaces:

OpenPGPPolicy

public class OpenPGPDefaultPolicy
extends java.lang.Object
implements OpenPGPPolicy

Nested Class Summary

Nested classes/interfaces inherited from interface org.bouncycastle.openpgp.api.OpenPGPPolicy

OpenPGPPolicy.OpenPGPNotationRegistry

Constructor Summary

Constructors

Constructor and Description
OpenPGPDefaultPolicy()

Method Summary

Modifier and Type	Method and Description
OpenPGPDefaultPolicy	acceptCertificationSignatureHashAlgorithm(int hashAlgorithmId)
OpenPGPDefaultPolicy	acceptCertificationSignatureHashAlgorithmUntil(int hashAlgorithmId, java.util.Date until)
OpenPGPDefaultPolicy	acceptDocumentSignatureHashAlgorithm(int hashAlgorithmId)
OpenPGPDefaultPolicy	acceptDocumentSignatureHashAlgorithmUntil(int hashAlgorithmId, java.util.Date until)
OpenPGPDefaultPolicy	acceptPublicKeyAlgorithm(int publicKeyAlgorithmId)
OpenPGPDefaultPolicy	acceptPublicKeyAlgorithmWithMinimalStrength(int publicKeyAlgorithmId, int minBitStrength)
OpenPGPDefaultPolicy	acceptSymmetricKeyAlgorithm(int symmetricKeyAlgorithmId)
OpenPGPDefaultPolicy	acceptSymmetricKeyAlgorithmUntil(int symmetricKeyAlgorithmId, java.util.Date until)
int	getDefaultCertificationSignatureHashAlgorithm() Return the default certification signature hash algorithm ID.
int	getDefaultDocumentSignatureHashAlgorithm() Return the default document signature hash algorithm ID.
int	getDefaultSymmetricKeyAlgorithm() Return the default symmetric-key algorithm, which is used as a fallback if symmetric encryption algorithm negotiation fails.
OpenPGPPolicy.OpenPGPNotationRegistry	getNotationRegistry() Return the policies OpenPGPPolicy.OpenPGPNotationRegistry containing known notation names.
boolean	hasAcceptableCertificationSignatureHashAlgorithm(PGPSignature signature) Return true, if the PGPSignature uses an acceptable certification signature hash algorithm.
boolean	hasAcceptableDocumentSignatureHashAlgorithm(PGPSignature signature) Return true, if the PGPSignature uses an acceptable data/document signature hash algorithm.
boolean	hasAcceptableRevocationSignatureHashAlgorithm(PGPSignature signature) Return true, if the PGPSignature uses an acceptable revocation signature hash algorithm.
boolean	hasAcceptableSignatureHashAlgorithm(PGPSignature signature) Return true, if the given PGPSignature was made using an acceptable signature hash algorithm.
boolean	hasNoCriticalUnknownNotations(PGPSignature signature) Return true, if the hashed subpacket area of the signature does NOT contain unknown critical notations.
boolean	hasNoCriticalUnknownSubpackets(PGPSignature signature) Return true, if the hashed subpacket area of the signature does NOT contain unknown critical subpackets.
boolean	isAcceptableCertificationSignatureHashAlgorithm(int hashAlgorithmId, java.util.Date signatureCreationTime) Return true, if the given hash algorithm is - at signature creation time - an acceptable certification signature hash algorithm.
boolean	isAcceptableDecryptionKey(PGPPublicKey key) Return true, if the given PGPPublicKey is acceptable for decrypting messages.
boolean	isAcceptableDocumentSignatureHashAlgorithm(int hashAlgorithmId, java.util.Date signatureCreationTime) Return true, if the given hash algorithm is - at signature creation time - an acceptable document signature hash algorithm.
boolean	isAcceptableEncryptionKey(PGPPublicKey key) Return true, if the given PGPPublicKey is acceptable for encrypting messages.
boolean	isAcceptablePublicKey(PGPPublicKey key) Return true, if the given PGPPublicKey is acceptable.
boolean	isAcceptablePublicKeyStrength(int publicKeyAlgorithmId, int bitStrength) Return true, if the given bitStrength is acceptable for the given public key algorithm ID.
boolean	isAcceptableRevocationSignatureHashAlgorithm(int hashAlgorithmId, java.util.Date signatureCreationTime) Return true, if the given hash algorithm is - at signature creation time - an acceptable revocation signature hash algorithm.
boolean	isAcceptableSignature(PGPSignature signature) Return true, if the given PGPSignature is acceptable (uses acceptable hash algorithm, does not contain unknown critical notations or subpackets).
boolean	isAcceptableSigningKey(PGPPublicKey key) Return true, if the given PGPPublicKey is an acceptable signing key.
boolean	isAcceptableSymmetricKeyAlgorithm(int symmetricKeyAlgorithmId) Return true, if the given symmetric-key algorithm is acceptable.
boolean	isAcceptableVerificationKey(PGPPublicKey key) Return true, if the given PGPPublicKey is an acceptable signature verification key.
boolean	isKnownSignatureSubpacket(int signatureSubpacketTag) Return true, if the given signature subpacket ID is known by the implementation.
OpenPGPDefaultPolicy	rejectHashAlgorithm(int hashAlgorithmId)
OpenPGPDefaultPolicy	rejectPublicKeyAlgorithm(int publicKeyAlgorithmId)
OpenPGPDefaultPolicy	rejectSymmetricKeyAlgorithm(int symmetricKeyAlgorithmId)
OpenPGPDefaultPolicy	setDefaultCertificationSignatureHashAlgorithm(int hashAlgorithmId)
OpenPGPDefaultPolicy	setDefaultDocumentSignatureHashAlgorithm(int hashAlgorithmId)
OpenPGPDefaultPolicy	setDefaultSymmetricKeyAlgorithm(int symmetricKeyAlgorithmId)

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Constructor Detail

OpenPGPDefaultPolicy

public OpenPGPDefaultPolicy()

Method Detail

isAcceptableSigningKey

public boolean isAcceptableSigningKey(PGPPublicKey key)

Return true, if the given PGPPublicKey is an acceptable signing key. Note: Although signing requires a secret key, we perform checks on the public part for consistency.

Specified by:

isAcceptableSigningKey in interface OpenPGPPolicy

Parameters:

key - key

Returns:

true if acceptable signing key

isAcceptableVerificationKey

public boolean isAcceptableVerificationKey(PGPPublicKey key)

Return true, if the given PGPPublicKey is an acceptable signature verification key. Note: The asymmetry between this and isAcceptableSigningKey(PGPPublicKey) is useful to prevent creation of signatures using a legacy key, while still allowing verification of signatures made using the same key.

Specified by:

isAcceptableVerificationKey in interface OpenPGPPolicy

Parameters:

key - key

Returns:

true if acceptable verification key

isAcceptableEncryptionKey

public boolean isAcceptableEncryptionKey(PGPPublicKey key)

Return true, if the given PGPPublicKey is acceptable for encrypting messages.

Specified by:

isAcceptableEncryptionKey in interface OpenPGPPolicy

Parameters:

key - key

Returns:

true if acceptable encryption key

isAcceptableDecryptionKey

public boolean isAcceptableDecryptionKey(PGPPublicKey key)

Return true, if the given PGPPublicKey is acceptable for decrypting messages. Note: Although decryption requires a secret key, we perform checks on the public part for consistency. The asymmetry between this and isAcceptableEncryptionKey(PGPPublicKey) is useful to prevent creation of new encrypted messages using a legacy key, while still allowing decryption of existing messages using the same key.

Specified by:

isAcceptableDecryptionKey in interface OpenPGPPolicy

Parameters:

key - key

Returns:

true if acceptable decryption key

isAcceptablePublicKey

public boolean isAcceptablePublicKey(PGPPublicKey key)

Return true, if the given PGPPublicKey is acceptable.

Specified by:

isAcceptablePublicKey in interface OpenPGPPolicy

Parameters:

key - key

Returns:

true if acceptable key

isAcceptableSignature

public boolean isAcceptableSignature(PGPSignature signature)

Return true, if the given PGPSignature is acceptable (uses acceptable hash algorithm, does not contain unknown critical notations or subpackets). Note: A signature being acceptable does NOT mean that it is correct or valid.

Specified by:

isAcceptableSignature in interface OpenPGPPolicy

Parameters:

signature - signature

Returns:

true if acceptable

hasAcceptableSignatureHashAlgorithm

public boolean hasAcceptableSignatureHashAlgorithm(PGPSignature signature)

Return true, if the given PGPSignature was made using an acceptable signature hash algorithm.

Specified by:

hasAcceptableSignatureHashAlgorithm in interface OpenPGPPolicy

Parameters:

signature - signature

Returns:

true if hash algorithm is acceptable

hasAcceptableDocumentSignatureHashAlgorithm

public boolean hasAcceptableDocumentSignatureHashAlgorithm(PGPSignature signature)

Return true, if the PGPSignature uses an acceptable data/document signature hash algorithm.

Specified by:

hasAcceptableDocumentSignatureHashAlgorithm in interface OpenPGPPolicy

Parameters:

signature - data / document signature

Returns:

true if hash algorithm is acceptable

hasAcceptableRevocationSignatureHashAlgorithm

public boolean hasAcceptableRevocationSignatureHashAlgorithm(PGPSignature signature)

Return true, if the PGPSignature uses an acceptable revocation signature hash algorithm.

Specified by:

hasAcceptableRevocationSignatureHashAlgorithm in interface OpenPGPPolicy

Parameters:

signature - revocation signature

Returns:

true if hash algorithm is acceptable

hasAcceptableCertificationSignatureHashAlgorithm

public boolean hasAcceptableCertificationSignatureHashAlgorithm(PGPSignature signature)

Return true, if the PGPSignature uses an acceptable certification signature hash algorithm.

Specified by:

hasAcceptableCertificationSignatureHashAlgorithm in interface OpenPGPPolicy

Parameters:

signature - certification signature

Returns:

true if hash algorithm is acceptable

hasNoCriticalUnknownNotations

public boolean hasNoCriticalUnknownNotations(PGPSignature signature)

Return true, if the hashed subpacket area of the signature does NOT contain unknown critical notations.

Specified by:

hasNoCriticalUnknownNotations in interface OpenPGPPolicy

Parameters:

signature - signature

Returns:

true if signature is free from unknown critical notations

hasNoCriticalUnknownSubpackets

public boolean hasNoCriticalUnknownSubpackets(PGPSignature signature)

Return true, if the hashed subpacket area of the signature does NOT contain unknown critical subpackets.

Specified by:

hasNoCriticalUnknownSubpackets in interface OpenPGPPolicy

Parameters:

signature - signature

Returns:

true if signature is free from unknown critical subpackets

isKnownSignatureSubpacket

public boolean isKnownSignatureSubpacket(int signatureSubpacketTag)

Return true, if the given signature subpacket ID is known by the implementation. Note: This method is only called for subpackets not recognized by SignatureSubpacketInputStream.

Specified by:

isKnownSignatureSubpacket in interface OpenPGPPolicy

Parameters:

signatureSubpacketTag - signature subpacket ID

Returns:

true if subpacket tag is known

rejectHashAlgorithm

public OpenPGPDefaultPolicy rejectHashAlgorithm(int hashAlgorithmId)

acceptCertificationSignatureHashAlgorithm

public OpenPGPDefaultPolicy acceptCertificationSignatureHashAlgorithm(int hashAlgorithmId)

acceptCertificationSignatureHashAlgorithmUntil

public OpenPGPDefaultPolicy acceptCertificationSignatureHashAlgorithmUntil(int hashAlgorithmId,
                                                                           java.util.Date until)

acceptDocumentSignatureHashAlgorithm

public OpenPGPDefaultPolicy acceptDocumentSignatureHashAlgorithm(int hashAlgorithmId)

acceptDocumentSignatureHashAlgorithmUntil

public OpenPGPDefaultPolicy acceptDocumentSignatureHashAlgorithmUntil(int hashAlgorithmId,
                                                                      java.util.Date until)

rejectSymmetricKeyAlgorithm

public OpenPGPDefaultPolicy rejectSymmetricKeyAlgorithm(int symmetricKeyAlgorithmId)

acceptSymmetricKeyAlgorithm

public OpenPGPDefaultPolicy acceptSymmetricKeyAlgorithm(int symmetricKeyAlgorithmId)

acceptSymmetricKeyAlgorithmUntil

public OpenPGPDefaultPolicy acceptSymmetricKeyAlgorithmUntil(int symmetricKeyAlgorithmId,
                                                             java.util.Date until)

rejectPublicKeyAlgorithm

public OpenPGPDefaultPolicy rejectPublicKeyAlgorithm(int publicKeyAlgorithmId)

acceptPublicKeyAlgorithm

public OpenPGPDefaultPolicy acceptPublicKeyAlgorithm(int publicKeyAlgorithmId)

acceptPublicKeyAlgorithmWithMinimalStrength

public OpenPGPDefaultPolicy acceptPublicKeyAlgorithmWithMinimalStrength(int publicKeyAlgorithmId,
                                                                        int minBitStrength)

isAcceptableDocumentSignatureHashAlgorithm

public boolean isAcceptableDocumentSignatureHashAlgorithm(int hashAlgorithmId,
                                                          java.util.Date signatureCreationTime)

Description copied from interface: OpenPGPPolicy

Return true, if the given hash algorithm is - at signature creation time - an acceptable document signature hash algorithm.

Specified by:

isAcceptableDocumentSignatureHashAlgorithm in interface OpenPGPPolicy

Parameters:

hashAlgorithmId - hash algorithm ID

signatureCreationTime - optional signature creation time

Returns:

true if hash algorithm is acceptable at creation time

isAcceptableRevocationSignatureHashAlgorithm

public boolean isAcceptableRevocationSignatureHashAlgorithm(int hashAlgorithmId,
                                                            java.util.Date signatureCreationTime)

Description copied from interface: OpenPGPPolicy

Return true, if the given hash algorithm is - at signature creation time - an acceptable revocation signature hash algorithm.

Specified by:

isAcceptableRevocationSignatureHashAlgorithm in interface OpenPGPPolicy

Parameters:

hashAlgorithmId - hash algorithm ID

signatureCreationTime - optional signature creation time

Returns:

true if hash algorithm is acceptable at creation time

isAcceptableCertificationSignatureHashAlgorithm

public boolean isAcceptableCertificationSignatureHashAlgorithm(int hashAlgorithmId,
                                                               java.util.Date signatureCreationTime)

Description copied from interface: OpenPGPPolicy

Return true, if the given hash algorithm is - at signature creation time - an acceptable certification signature hash algorithm.

Specified by:

isAcceptableCertificationSignatureHashAlgorithm in interface OpenPGPPolicy

Parameters:

hashAlgorithmId - hash algorithm ID

signatureCreationTime - optional signature creation time

Returns:

true if hash algorithm is acceptable at creation time

getDefaultCertificationSignatureHashAlgorithm

public int getDefaultCertificationSignatureHashAlgorithm()

Description copied from interface: OpenPGPPolicy

Return the default certification signature hash algorithm ID. This is used as fallback, if negotiation of a commonly supported hash algorithm fails.

Specified by:

getDefaultCertificationSignatureHashAlgorithm in interface OpenPGPPolicy

Returns:

default certification signature hash algorithm ID

setDefaultCertificationSignatureHashAlgorithm

public OpenPGPDefaultPolicy setDefaultCertificationSignatureHashAlgorithm(int hashAlgorithmId)

getDefaultDocumentSignatureHashAlgorithm

public int getDefaultDocumentSignatureHashAlgorithm()

Description copied from interface: OpenPGPPolicy

Return the default document signature hash algorithm ID. This is used as fallback, if negotiation of a commonly supported hash algorithm fails.

Specified by:

getDefaultDocumentSignatureHashAlgorithm in interface OpenPGPPolicy

Returns:

default document signature hash algorithm ID

setDefaultDocumentSignatureHashAlgorithm

public OpenPGPDefaultPolicy setDefaultDocumentSignatureHashAlgorithm(int hashAlgorithmId)

isAcceptableSymmetricKeyAlgorithm

public boolean isAcceptableSymmetricKeyAlgorithm(int symmetricKeyAlgorithmId)

Description copied from interface: OpenPGPPolicy

Return true, if the given symmetric-key algorithm is acceptable.

Specified by:

isAcceptableSymmetricKeyAlgorithm in interface OpenPGPPolicy

Parameters:

symmetricKeyAlgorithmId - symmetric-key algorithm

Returns:

true if symmetric-key algorithm is acceptable

getDefaultSymmetricKeyAlgorithm

public int getDefaultSymmetricKeyAlgorithm()

Description copied from interface: OpenPGPPolicy

Return the default symmetric-key algorithm, which is used as a fallback if symmetric encryption algorithm negotiation fails.

Specified by:

getDefaultSymmetricKeyAlgorithm in interface OpenPGPPolicy

Returns:

default symmetric-key algorithm

setDefaultSymmetricKeyAlgorithm

public OpenPGPDefaultPolicy setDefaultSymmetricKeyAlgorithm(int symmetricKeyAlgorithmId)

isAcceptablePublicKeyStrength

public boolean isAcceptablePublicKeyStrength(int publicKeyAlgorithmId,
                                             int bitStrength)

Description copied from interface: OpenPGPPolicy

Return true, if the given bitStrength is acceptable for the given public key algorithm ID.

Specified by:

isAcceptablePublicKeyStrength in interface OpenPGPPolicy

Parameters:

publicKeyAlgorithmId - ID of a public key algorithm

bitStrength - key bit strength

Returns:

true if strength is acceptable

getNotationRegistry

public OpenPGPPolicy.OpenPGPNotationRegistry getNotationRegistry()

Description copied from interface: OpenPGPPolicy

Return the policies OpenPGPPolicy.OpenPGPNotationRegistry containing known notation names.

Specified by:

getNotationRegistry in interface OpenPGPPolicy

Returns:

notation registry