org.bouncycastle.openpgp.PGPSignatureSubpacketVector Maven / Gradle / Ivy

Go to download

Show more of this group Show more artifacts with this name
Show all versions of bcpg-jdk14 Show documentation

The Bouncy Castle Java API for handling the OpenPGP protocol. This jar contains the OpenPGP API for JDK 1.4. The APIs can be used in conjunction with a JCE/JCA provider such as the one provided with the Bouncy Castle Cryptography APIs.

The newest version!

package org.bouncycastle.openpgp;

import java.io.IOException;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Date;
import java.util.List;

import org.bouncycastle.bcpg.SignaturePacket;
import org.bouncycastle.bcpg.SignatureSubpacket;
import org.bouncycastle.bcpg.SignatureSubpacketTags;
import org.bouncycastle.bcpg.sig.Exportable;
import org.bouncycastle.bcpg.sig.Features;
import org.bouncycastle.bcpg.sig.IntendedRecipientFingerprint;
import org.bouncycastle.bcpg.sig.IssuerFingerprint;
import org.bouncycastle.bcpg.sig.IssuerKeyID;
import org.bouncycastle.bcpg.sig.KeyExpirationTime;
import org.bouncycastle.bcpg.sig.KeyFlags;
import org.bouncycastle.bcpg.sig.LibrePGPPreferredEncryptionModes;
import org.bouncycastle.bcpg.sig.NotationData;
import org.bouncycastle.bcpg.sig.PolicyURI;
import org.bouncycastle.bcpg.sig.PreferredAEADCiphersuites;
import org.bouncycastle.bcpg.sig.PreferredAlgorithms;
import org.bouncycastle.bcpg.sig.PrimaryUserID;
import org.bouncycastle.bcpg.sig.RegularExpression;
import org.bouncycastle.bcpg.sig.Revocable;
import org.bouncycastle.bcpg.sig.RevocationKey;
import org.bouncycastle.bcpg.sig.RevocationReason;
import org.bouncycastle.bcpg.sig.SignatureCreationTime;
import org.bouncycastle.bcpg.sig.SignatureExpirationTime;
import org.bouncycastle.bcpg.sig.SignatureTarget;
import org.bouncycastle.bcpg.sig.SignerUserID;
import org.bouncycastle.bcpg.sig.TrustSignature;

/**
 * Container for a list of signature subpackets.
 */
public class PGPSignatureSubpacketVector
{
    /**
     * Create a new {@link PGPSignatureSubpacketVector} from the given {@link Collection} of
     * {@link SignatureSubpacket} items.
     * If the collection is  null

, return an empty {@link PGPSignatureSubpacketVector}.
     *
     * @param packets collection of items or null
     * @return PGPSignatureSubpacketVector
     */
    public static PGPSignatureSubpacketVector fromSubpackets(Collection  packets)
    {
        if (packets == null)
        {
            return fromSubpackets((SignatureSubpacket[]) null);
        }
        else
        {
            return fromSubpackets((SignatureSubpacket[])packets.toArray(new SignatureSubpacket[0]));
        }
    }

    /**
     * Create a new {@link PGPSignatureSubpacketVector} from the given {@link SignatureSubpacket[]}.
     * If the array is  null, return an empty {@link PGPSignatureSubpacketVector}.
     *
     * @param packets array of items or null
     * @return PGPSignatureSubpacketVector
     */
    public static PGPSignatureSubpacketVector fromSubpackets(SignatureSubpacket[] packets)
    {
        if (packets == null)
        {
            packets = new SignatureSubpacket[0];
        }
        return new PGPSignatureSubpacketVector(packets);
    }

    SignatureSubpacket[] packets;

    PGPSignatureSubpacketVector(
        SignatureSubpacket[] packets)
    {
        this.packets = packets;
    }

    public SignatureSubpacket getSubpacket(
        int type)
    {
        for (int i = 0; i != packets.length; i++)
        {
            if (packets[i].getType() == type)
            {
                return packets[i];
            }
        }

        return null;
    }

    /**
     * Return true if a particular subpacket type exists.
     *
     * @param type type to look for.
     * @return true if present, false otherwise.
     */
    public boolean hasSubpacket(
        int type)
    {
        return getSubpacket(type) != null;
    }

    /**
     * Return all signature subpackets of the passed in type.
     *
     * @param type subpacket type code
     * @return an array of zero or more matching subpackets.
     */
    public SignatureSubpacket[] getSubpackets(
        int type)
    {
        List list = new ArrayList();

        for (int i = 0; i != packets.length; i++)
        {
            if (packets[i].getType() == type)
            {
                list.add(packets[i]);
            }
        }

        return (SignatureSubpacket[])list.toArray(new SignatureSubpacket[]{});
    }

    public PGPSignatureList getEmbeddedSignatures()
        throws PGPException
    {
        SignatureSubpacket[] sigs = getSubpackets(SignatureSubpacketTags.EMBEDDED_SIGNATURE);
        ArrayList l = new ArrayList();

        for (int i = 0; i < sigs.length; i++)
        {
            try
            {
                l.add(new PGPSignature(SignaturePacket.fromByteArray(sigs[i].getData())));
            }
            catch (IOException e)
            {
                throw new PGPException("Unable to parse signature packet: " + e.getMessage(), e);
            }
        }

        return new PGPSignatureList((PGPSignature[])l.toArray(new PGPSignature[l.size()]));
    }

    public NotationData[] getNotationDataOccurrences()
    {
        SignatureSubpacket[] notations = getSubpackets(SignatureSubpacketTags.NOTATION_DATA);
        NotationData[] vals = new NotationData[notations.length];
        for (int i = 0; i < notations.length; i++)
        {
            vals[i] = (NotationData)notations[i];
        }

        return vals;
    }

    /**
     * @deprecated use  getNotationDataOccurrences()
     */
    public NotationData[] getNotationDataOccurences()
    {
        return getNotationDataOccurrences();
    }

    /**
     * Return all {@link NotationData} occurrences which match the given notation name.
     *
     * @param notationName notation name
     * @return notations with matching name
     */
    public NotationData[] getNotationDataOccurrences(String notationName)
    {
        NotationData[] notations = getNotationDataOccurrences();
        List  notationsWithName = new ArrayList ();
        for (int i = 0; i != notations.length; i++)
        {
            NotationData notation = notations[i];
            if (notation.getNotationName().equals(notationName))
            {
                notationsWithName.add(notation);
            }
        }
        return (NotationData[])notationsWithName.toArray(new NotationData[0]);
    }

    public long getIssuerKeyID()
    {
        SignatureSubpacket p = this.getSubpacket(SignatureSubpacketTags.ISSUER_KEY_ID);

        if (p == null)
        {
            return 0;
        }

        return ((IssuerKeyID)p).getKeyID();
    }

    public Date getSignatureCreationTime()
    {
        SignatureSubpacket p = this.getSubpacket(SignatureSubpacketTags.CREATION_TIME);

        if (p == null)
        {
            return null;
        }

        return ((SignatureCreationTime)p).getTime();
    }

    /**
     * Return the number of seconds a signature is valid for after its creation date. A value of zero means
     * the signature never expires.
     *
     * @return seconds a signature is valid for.
     */
    public long getSignatureExpirationTime()
    {
        SignatureSubpacket p = this.getSubpacket(SignatureSubpacketTags.EXPIRE_TIME);

        if (p == null)
        {
            return 0;
        }

        return ((SignatureExpirationTime)p).getTime();
    }

    /**
     * Return the number of seconds a key is valid for after its creation date. A value of zero means
     * the key never expires.
     *
     * @return seconds a key is valid for.
     */
    public long getKeyExpirationTime()
    {
        SignatureSubpacket p = this.getSubpacket(SignatureSubpacketTags.KEY_EXPIRE_TIME);

        if (p == null)
        {
            return 0;
        }

        return ((KeyExpirationTime)p).getTime();
    }

    public int[] getPreferredHashAlgorithms()
    {
        SignatureSubpacket p = this.getSubpacket(SignatureSubpacketTags.PREFERRED_HASH_ALGS);

        if (p == null)
        {
            return null;
        }

        return ((PreferredAlgorithms)p).getPreferences();
    }

    public int[] getPreferredSymmetricAlgorithms()
    {
        SignatureSubpacket p = this.getSubpacket(SignatureSubpacketTags.PREFERRED_SYM_ALGS);

        if (p == null)
        {
            return null;
        }

        return ((PreferredAlgorithms)p).getPreferences();
    }

    public int[] getPreferredCompressionAlgorithms()
    {
        SignatureSubpacket p = this.getSubpacket(SignatureSubpacketTags.PREFERRED_COMP_ALGS);

        if (p == null)
        {
            return null;
        }

        return ((PreferredAlgorithms)p).getPreferences();
    }

    /**
     * This method is BROKEN!
     * @deprecated use {@link #getPreferredAEADCiphersuites()} or {@link #getPreferredLibrePgpEncryptionModes()}
     * instead.
     * @return preferred AEAD Algorithms
     */
     
    public int[] getPreferredAEADAlgorithms()
    {
        SignatureSubpacket p = this.getSubpacket(SignatureSubpacketTags.PREFERRED_AEAD_ALGORITHMS);

        if (p == null)
        {
            return null;
        }

        return ((PreferredAlgorithms)p).getPreferences();
    }

    /**
     * Return the preferred AEAD ciphersuites denoted in the signature.
     *
     * @return OpenPGP AEAD ciphersuites
     */
    public PreferredAEADCiphersuites getPreferredAEADCiphersuites()
    {
        SignatureSubpacket p = this.getSubpacket(SignatureSubpacketTags.PREFERRED_AEAD_ALGORITHMS);

        if (p == null)
        {
            return null;
        }
        return (PreferredAEADCiphersuites) p;
    }

    /**
     * Return the preferred LibrePGP encryption modes denoted in the signature.
     * Note: The LibrePGP spec states that this subpacket shall be ignored and the application
     * shall instead assume {@link org.bouncycastle.bcpg.AEADAlgorithmTags#OCB}.
     *
     * @return LibrePGP encryption modes
     */
    public int[] getPreferredLibrePgpEncryptionModes()
    {
        SignatureSubpacket p = this.getSubpacket(SignatureSubpacketTags.PREFERRED_AEAD_ALGORITHMS);

        if (p == null)
        {
            return null;
        }
        return ((LibrePGPPreferredEncryptionModes) p).getPreferences();
    }

    public int getKeyFlags()
    {
        SignatureSubpacket p = this.getSubpacket(SignatureSubpacketTags.KEY_FLAGS);

        if (p == null)
        {
            return 0;
        }

        return ((KeyFlags)p).getFlags();
    }

    public String getSignerUserID()
    {
        SignatureSubpacket p = this.getSubpacket(SignatureSubpacketTags.SIGNER_USER_ID);

        if (p == null)
        {
            return null;
        }

        return ((SignerUserID)p).getID();
    }

    public boolean isPrimaryUserID()
    {
        PrimaryUserID primaryId = (PrimaryUserID)this.getSubpacket(SignatureSubpacketTags.PRIMARY_USER_ID);

        if (primaryId != null)
        {
            return primaryId.isPrimaryUserID();
        }

        return false;
    }

    public int[] getCriticalTags()
    {
        int count = 0;

        for (int i = 0; i != packets.length; i++)
        {
            if (packets[i].isCritical())
            {
                count++;
            }
        }

        int[] list = new int[count];

        count = 0;

        for (int i = 0; i != packets.length; i++)
        {
            if (packets[i].isCritical())
            {
                list[count++] = packets[i].getType();
            }
        }

        return list;
    }

    public SignatureTarget getSignatureTarget()
    {
        SignatureSubpacket p = this.getSubpacket(SignatureSubpacketTags.SIGNATURE_TARGET);

        if (p == null)
        {
            return null;
        }

        return new SignatureTarget(p.isCritical(), p.isLongLength(), p.getData());
    }

    public Features getFeatures()
    {
        SignatureSubpacket p = this.getSubpacket(SignatureSubpacketTags.FEATURES);

        if (p == null)
        {
            return null;
        }

        return new Features(p.isCritical(), p.isLongLength(), p.getData());
    }

    public IssuerFingerprint getIssuerFingerprint()
    {
        SignatureSubpacket p = this.getSubpacket(SignatureSubpacketTags.ISSUER_FINGERPRINT);

        if (p == null)
        {
            return null;
        }

        return new IssuerFingerprint(p.isCritical(), p.isLongLength(), p.getData());
    }

    public IntendedRecipientFingerprint getIntendedRecipientFingerprint()
    {
        SignatureSubpacket p = this.getSubpacket(SignatureSubpacketTags.INTENDED_RECIPIENT_FINGERPRINT);

        if (p == null)
        {
            return null;
        }

        return new IntendedRecipientFingerprint(p.isCritical(), p.isLongLength(), p.getData());
    }

    public IntendedRecipientFingerprint[] getIntendedRecipientFingerprints()
    {
        SignatureSubpacket[] subpackets = this.getSubpackets(SignatureSubpacketTags.INTENDED_RECIPIENT_FINGERPRINT);
        IntendedRecipientFingerprint[] recipients = new IntendedRecipientFingerprint[subpackets.length];
        for (int i = 0; i < recipients.length; i++)
        {
            recipients[i] = new IntendedRecipientFingerprint(subpackets[i].isCritical(), subpackets[i].isLongLength(), subpackets[i].getData());
        }
        return recipients;
    }

    public Exportable getExportable()
    {
        SignatureSubpacket p = getSubpacket(SignatureSubpacketTags.EXPORTABLE);
        if (p == null)
        {
            return null;
        }

        return new Exportable(p.isCritical(), p.isLongLength(), p.getData());
    }

    public boolean isExportable()
    {
        Exportable exportable = getExportable();
        return exportable == null || exportable.isExportable();
    }

    public PolicyURI getPolicyURI()
    {
        SignatureSubpacket p = getSubpacket(SignatureSubpacketTags.POLICY_URL);
        if (p == null)
        {
            return null;
        }
        return new PolicyURI(p.isCritical(), p.isLongLength(), p.getData());
    }

    public PolicyURI[] getPolicyURIs()
    {
        SignatureSubpacket[] subpackets = getSubpackets(SignatureSubpacketTags.POLICY_URL);
        PolicyURI[] policyURIS = new PolicyURI[subpackets.length];
        for (int i = 0; i < subpackets.length; i++)
        {
            SignatureSubpacket p = subpackets[i];
            policyURIS[i] = new PolicyURI(p.isCritical(), p.isLongLength(), p.getData());
        }
        return policyURIS;
    }

    public RegularExpression getRegularExpression()
    {
        SignatureSubpacket p = getSubpacket(SignatureSubpacketTags.REG_EXP);
        if (p == null)
        {
            return null;
        }
        return new RegularExpression(p.isCritical(), p.isLongLength(), p.getData());
    }

    public RegularExpression[] getRegularExpressions()
    {
        SignatureSubpacket[] subpackets = getSubpackets(SignatureSubpacketTags.REG_EXP);
        RegularExpression[] regexes = new RegularExpression[subpackets.length];
        for (int i = 0; i < regexes.length; i++)
        {
            SignatureSubpacket p = subpackets[i];
            regexes[i] = new RegularExpression(p.isCritical(), p.isLongLength(), p.getData());
        }
        return regexes;
    }

    public Revocable getRevocable()
    {
        SignatureSubpacket p = getSubpacket(SignatureSubpacketTags.REVOCABLE);
        if (p == null)
        {
            return null;
        }

        return new Revocable(p.isCritical(), p.isLongLength(), p.getData());
    }

    public boolean isRevocable()
    {
        Revocable revocable = getRevocable();
        return revocable == null || revocable.isRevocable();
    }

    public RevocationKey[] getRevocationKeys()
    {
        SignatureSubpacket[] subpackets = getSubpackets(SignatureSubpacketTags.REVOCATION_KEY);
        RevocationKey[] revocationKeys = new RevocationKey[subpackets.length];
        for (int i = 0; i < revocationKeys.length; i++)
        {
            revocationKeys[i] = new RevocationKey(subpackets[i].isCritical(), subpackets[i].isLongLength(), subpackets[i].getData());
        }
        return revocationKeys;
    }

    public RevocationReason getRevocationReason()
    {
        SignatureSubpacket p = getSubpacket(SignatureSubpacketTags.REVOCATION_REASON);
        if (p == null)
        {
            return null;
        }
        return new RevocationReason(p.isCritical(), p.isLongLength(), p.getData());
    }

    public TrustSignature getTrust()
    {
        SignatureSubpacket p = getSubpacket(SignatureSubpacketTags.TRUST_SIG);
        if (p == null)
        {
            return null;
        }
        return new TrustSignature(p.isCritical(), p.isLongLength(), p.getData());
    }

    /**
     * Return the number of packets this vector contains.
     *
     * @return size of the packet vector.
     */
    public int size()
    {
        return packets.length;
    }

    SignatureSubpacket[] toSubpacketArray()
    {
        return packets;
    }

    /**
     * Return a copy of the subpackets in this vector.
     *
     * @return an array containing the vector subpackets in order.
     */
    public SignatureSubpacket[] toArray()
    {
        SignatureSubpacket[] rv = new SignatureSubpacket[packets.length];

        System.arraycopy(packets, 0, rv, 0, rv.length);

        return rv;
    }
}