bc-java/pg/src/main/java/org/bouncycastle/openpgp/api/Utils.java at 5e613d2445121fcc625fd6fc2df4b8468a860554 · pgpainless/bc-java · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
package org.bouncycastle.openpgp.api;

import java.io.IOException;
import java.util.Date;

import org.bouncycastle.openpgp.PGPException;
import org.bouncycastle.openpgp.PGPKeyPair;
import org.bouncycastle.openpgp.PGPPrivateKey;
import org.bouncycastle.openpgp.PGPPublicKey;
import org.bouncycastle.openpgp.PGPSignature;
import org.bouncycastle.openpgp.PGPSignatureGenerator;
import org.bouncycastle.openpgp.PGPSignatureSubpacketGenerator;

class Utils
{
    static void addEmbeddedSiganture(final PGPSignature backSig, PGPSignatureSubpacketGenerator hashedSubpackets)
        throws PGPException
    {
        if (backSig != null)
        {
            try
            {
                hashedSubpackets.addEmbeddedSignature(true, backSig);
            }
            catch (IOException e)
            {
                throw new PGPException("Cannot encode embedded back-signature.", e);
            }
        }
    }

    static PGPSignature getBackSignature(PGPKeyPair signingSubkey, SignatureParameters backSigParameters,
                                         PGPPublicKey publicPrimaryKey, OpenPGPImplementation implementation, Date date)
        throws PGPException
    {
        PGPSignature backSig = null;
        if (backSigParameters != null)
        {
            PGPSignatureGenerator backSigGen = getPgpSignatureGenerator(implementation, signingSubkey.getPublicKey(),
                signingSubkey.getPrivateKey(), backSigParameters, date, null);

            backSig = backSigGen.generateCertification(publicPrimaryKey, signingSubkey.getPublicKey());
        }
        return backSig;
    }

    static PGPPublicKey injectCertification(PGPPublicKey publicKey, PGPSignatureGenerator revGen, PGPPublicKey publicPrimaryKey)
        throws PGPException
    {
        PGPSignature revocation = revGen.generateCertification(publicPrimaryKey, publicKey);
        return PGPPublicKey.addCertification(publicKey, revocation);
    }

    static PGPPublicKey injectCertification(PGPPublicKey publicKey, PGPSignatureGenerator revGen)
        throws PGPException
    {
        // Inject signature into the certificate
        PGPSignature revocation = revGen.generateCertification(publicKey);
        return PGPPublicKey.addCertification(publicKey, revocation);
    }

    static PGPPublicKey injectCertification(String userId, PGPPublicKey publicPrimaryKey, PGPSignatureGenerator uidSigGen)
        throws PGPException
    {
        // Inject UID and signature into the certificate
        PGPSignature uidSig = uidSigGen.generateCertification(userId, publicPrimaryKey);
        return PGPPublicKey.addCertification(publicPrimaryKey, userId, uidSig);
    }

    public interface HashedSubpacketsOperation
    {
        void operate(PGPSignatureSubpacketGenerator hashedSubpackets)
            throws PGPException;
    }

    static PGPSignatureGenerator getPgpSignatureGenerator(OpenPGPImplementation implementationProvider,
                                                          PGPPublicKey publicKey,
                                                          PGPPrivateKey privateKey,
                                                          SignatureParameters parameters,
                                                          Date date,
                                                          HashedSubpacketsOperation operation)
        throws PGPException
    {
        PGPSignatureGenerator sigGen = new PGPSignatureGenerator(
            implementationProvider.pgpContentSignerBuilder(
                publicKey.getAlgorithm(),
                parameters.getSignatureHashAlgorithmId()),
            publicKey);
        sigGen.init(parameters.getSignatureType(), privateKey);

        return applyDefaultSubpackets(publicKey, parameters, date, operation, sigGen);
    }

    static PGPSignatureGenerator applyDefaultSubpackets(PGPPublicKey publicKey, SignatureParameters parameters, Date date, HashedSubpacketsOperation operation, PGPSignatureGenerator sigGen) throws PGPException {
        final PGPSignatureSubpacketGenerator hashedSubpackets = new PGPSignatureSubpacketGenerator();
        hashedSubpackets.setIssuerFingerprint(true, publicKey);
        if (date != null)
        {
            hashedSubpackets.setSignatureCreationTime(date);
        }
        if (operation != null)
        {
            operation.operate(hashedSubpackets);
        }
        parameters.applyToHashedSubpackets(hashedSubpackets);
        sigGen.setHashedSubpackets(hashedSubpackets.generate());

        PGPSignatureSubpacketGenerator unhashedSubpackets = new PGPSignatureSubpacketGenerator();
        unhashedSubpackets = parameters.applyToUnhashedSubpackets(unhashedSubpackets);
        sigGen.setUnhashedSubpackets(unhashedSubpackets.generate());
        return sigGen;
    }

    static SignatureParameters applySignatureParameters(SignatureParameters.Callback signatureCallback, SignatureParameters parameters)
    {
        if (signatureCallback != null)
        {
            parameters = signatureCallback.apply(parameters);
        }
        return parameters;
    }
}