Example usage for org.bouncycastle.openpgp PGPSignature CANONICAL_TEXT_DOCUMENT

List of usage examples for org.bouncycastle.openpgp PGPSignature CANONICAL_TEXT_DOCUMENT

  1. HOME
  2. Java
  3. org.bouncycastle
  4. org.bouncycastle.openpgp.*
  5. PGPSignature
  6. CANONICAL_TEXT_DOCUMENT

Introduction

In this page you can find the example usage for org.bouncycastle.openpgp PGPSignature CANONICAL_TEXT_DOCUMENT.

Prototype

int CANONICAL_TEXT_DOCUMENT

To view the source code for org.bouncycastle.openpgp PGPSignature CANONICAL_TEXT_DOCUMENT.

Click Source Link

Usage

From source file:com.github.sannies.nexusaptplugin.sign.PGPSigner.java

License:Apache License

/**
 * Creates a clear sign signature over the input data. (Not detached)
 *
 * @param input      the content to be signed
 * @param output     the output destination of the signature
 *//*ww w  .  java  2  s .c o  m*/
public void clearSign(InputStream input, OutputStream output)
        throws IOException, PGPException, GeneralSecurityException {
    int digest = PGPUtil.SHA1;

    PGPSignatureGenerator signatureGenerator = new PGPSignatureGenerator(
            new BcPGPContentSignerBuilder(privateKey.getPublicKeyPacket().getAlgorithm(), digest));
    signatureGenerator.init(PGPSignature.CANONICAL_TEXT_DOCUMENT, privateKey);

    ArmoredOutputStream armoredOutput = new ArmoredOutputStream(output);
    armoredOutput.beginClearText(digest);

    BufferedReader reader = new BufferedReader(new InputStreamReader(input));

    String line;
    while ((line = reader.readLine()) != null) {
        // trailing spaces must be removed for signature calculation (see http://tools.ietf.org/html/rfc4880#section-7.1)
        byte[] data = trim(line).getBytes("UTF-8");

        armoredOutput.write(data);
        armoredOutput.write(EOL);

        signatureGenerator.update(data);
        signatureGenerator.update(EOL);
    }

    armoredOutput.endClearText();

    PGPSignature signature = signatureGenerator.generate();
    signature.encode(new BCPGOutputStream(armoredOutput));

    armoredOutput.close();
}

From source file:com.navnorth.learningregistry.LRSigner.java

License:Apache License

/**
 * Encodes the provided message with the private key and pass phrase set in configuration
 *
 * @param message Message to encode//w  w w.  jav  a  2 s .c o  m
 * @return Encoded message
 * @throws LRException SIGNING_FAILED if the document cannot be signed, NO_KEY if the key cannot be obtained
 */
private String signEnvelopeData(String message) throws LRException {
    // Throw an exception if any of the required fields are null
    if (passPhrase == null || publicKeyLocation == null || privateKey == null) {
        throw new LRException(LRException.NULL_FIELD);
    }

    // Add the provider here so that after signing, we can remove the provider.
    // This allows using this code from multiple separate class loaders while Bouncy Castle is on a separate class loader
    BouncyCastleProvider provider = new BouncyCastleProvider();
    Security.addProvider(provider);

    try {

        // Get an InputStream for the private key
        InputStream privateKeyStream = getPrivateKeyStream(privateKey);

        // Get an OutputStream for the result
        ByteArrayOutputStream result = new ByteArrayOutputStream();
        ArmoredOutputStream aOut = new ArmoredOutputStream(result);

        // Get the pass phrase
        char[] privateKeyPassword = passPhrase.toCharArray();

        try {
            // Get the private key from the InputStream
            PGPSecretKey sk = readSecretKey(privateKeyStream);
            PGPPrivateKey pk = sk.extractPrivateKey(
                    new JcePBESecretKeyDecryptorBuilder().setProvider("BC").build(privateKeyPassword));
            PGPSignatureGenerator sGen = new PGPSignatureGenerator(
                    new JcaPGPContentSignerBuilder(sk.getPublicKey().getAlgorithm(), PGPUtil.SHA256)
                            .setProvider("BC"));
            PGPSignatureSubpacketGenerator spGen = new PGPSignatureSubpacketGenerator();

            // Clear sign the message
            java.util.Iterator it = sk.getPublicKey().getUserIDs();
            if (it.hasNext()) {
                spGen.setSignerUserID(false, (String) it.next());
                sGen.setHashedSubpackets(spGen.generate());
            }
            aOut.beginClearText(PGPUtil.SHA256);
            sGen.init(PGPSignature.CANONICAL_TEXT_DOCUMENT, pk);
            byte[] msg = message.getBytes();
            sGen.update(msg, 0, msg.length);
            aOut.write(msg, 0, msg.length);
            BCPGOutputStream bOut = new BCPGOutputStream(aOut);
            aOut.endClearText();
            sGen.generate().encode(bOut);
            aOut.close();

            String strResult = result.toString("utf8");

            // for whatever reason, bouncycastle is failing to put a linebreak before "-----BEGIN PGP SIGNATURE"
            strResult = strResult.replaceAll("([a-z0-9])-----BEGIN PGP SIGNATURE-----",
                    "$1\n-----BEGIN PGP SIGNATURE-----");

            return strResult;
        } catch (Exception e) {
            throw new LRException(LRException.SIGNING_FAILED, e);
        } finally {
            try {
                if (privateKeyStream != null) {
                    privateKeyStream.close();
                }

                result.close();
            } catch (IOException e) {
                //Could not close the streams
            }
        }
    } finally {
        Security.removeProvider(provider.getName());
    }
}

From source file:exchange.User.java

public String addSignature(String message) throws PGPException, SignatureException, IOException {
    message = (message.endsWith("#")) ? message.substring(0, message.length() - 1) : message;
    PGPSignatureGenerator sigGen = new PGPSignatureGenerator(
            new BcPGPContentSignerBuilder(keyAlgorithm, PGPUtil.SHA256));

    sigGen.init(PGPSignature.CANONICAL_TEXT_DOCUMENT, privateKey);
    sigGen.update(message.getBytes());//  w  ww .  jav  a 2  s.  c o  m
    PGPSignature signature = sigGen.generate();
    System.out.println(message);
    return message + msgDelimiter + DatatypeConverter.printBase64Binary(signature.getEncoded());
}

From source file:net.staticsnow.nexus.repository.apt.internal.gpg.AptSigningFacet.java

License:Open Source License

public byte[] signInline(String input) throws IOException, PGPException {
    PGPSecretKey signKey = readSecretKey();
    PGPPrivateKey privKey = signKey.extractPrivateKey(
            new JcePBESecretKeyDecryptorBuilder().setProvider("BC").build(config.passphrase.toCharArray()));
    PGPSignatureGenerator sigGenerator = new PGPSignatureGenerator(
            new JcaPGPContentSignerBuilder(signKey.getPublicKey().getAlgorithm(), PGPUtil.SHA256)
                    .setProvider("BC"));
    sigGenerator.init(PGPSignature.CANONICAL_TEXT_DOCUMENT, privKey);

    @SuppressWarnings("unchecked")
    Iterator<String> userIds = signKey.getUserIDs();
    if (userIds.hasNext()) {
        PGPSignatureSubpacketGenerator sigSubpacketGenerator = new PGPSignatureSubpacketGenerator();
        sigSubpacketGenerator.setSignerUserID(false, userIds.next());
        sigGenerator.setHashedSubpackets(sigSubpacketGenerator.generate());
    }//from w w  w . j a v a2  s .  c  o m

    String[] lines = input.split("\r?\n");
    ByteArrayOutputStream buffer = new ByteArrayOutputStream();
    try (ArmoredOutputStream aOut = new ArmoredOutputStream(buffer)) {
        aOut.beginClearText(PGPUtil.SHA256);

        boolean firstLine = true;
        for (String line : lines) {
            String sigLine = (firstLine ? "" : "\r\n") + line.replaceAll("\\s*$", "");
            sigGenerator.update(sigLine.getBytes(Charsets.UTF_8));
            aOut.write((line + "\n").getBytes(Charsets.UTF_8));
            firstLine = false;
        }
        aOut.endClearText();

        BCPGOutputStream bOut = new BCPGOutputStream(aOut);
        sigGenerator.generate().encode(bOut);
    }
    return buffer.toByteArray();
}

From source file:org.eclipse.packagedrone.repo.signing.pgp.internal.AbstractSecretKeySigningService.java

License:Open Source License

@Override
public void sign(final InputStream in, final OutputStream out, final boolean inline) throws Exception {
    final int digest = HashAlgorithmTags.SHA1;
    final PGPSignatureGenerator signatureGenerator = new PGPSignatureGenerator(
            new BcPGPContentSignerBuilder(this.privateKey.getPublicKeyPacket().getAlgorithm(), digest));

    if (inline) {
        signatureGenerator.init(PGPSignature.CANONICAL_TEXT_DOCUMENT, this.privateKey);
    } else {/*from   w ww. j a v a  2s . c  om*/
        signatureGenerator.init(PGPSignature.BINARY_DOCUMENT, this.privateKey);
    }

    final ArmoredOutputStream armoredOutput = new ArmoredOutputStream(out);
    armoredOutput.setHeader("Version", VersionInformation.VERSIONED_PRODUCT);

    if (inline) {
        armoredOutput.beginClearText(digest);

        final LineNumberReader lnr = new LineNumberReader(new InputStreamReader(in, StandardCharsets.UTF_8));

        String line;
        while ((line = lnr.readLine()) != null) {
            if (lnr.getLineNumber() > 1) {
                signatureGenerator.update(NL_DATA);
            }

            final byte[] data = trimTrailing(line).getBytes(StandardCharsets.UTF_8);

            if (inline) {
                armoredOutput.write(data);
                armoredOutput.write(NL_DATA);
            }
            signatureGenerator.update(data);
        }

        armoredOutput.endClearText();
    } else {

        final byte[] buffer = new byte[4096];
        int rc;
        while ((rc = in.read(buffer)) >= 0) {
            signatureGenerator.update(buffer, 0, rc);
        }
    }

    final PGPSignature signature = signatureGenerator.generate();
    signature.encode(new BCPGOutputStream(armoredOutput));

    armoredOutput.close();
}

From source file:org.m1theo.apt.repo.signing.PGPSigner.java

License:Apache License

/**
 * Creates a clear sign signature over the input data. (Not detached)
 *
 * @param input      the content to be signed
 * @param output     the output destination of the signature
 */// ww w .  j av  a  2s  .  c  om
public void clearSign(InputStream input, OutputStream output)
        throws IOException, PGPException, GeneralSecurityException {

    PGPSignatureGenerator signatureGenerator = new PGPSignatureGenerator(
            new BcPGPContentSignerBuilder(privateKey.getPublicKeyPacket().getAlgorithm(), digest));
    signatureGenerator.init(PGPSignature.CANONICAL_TEXT_DOCUMENT, privateKey);

    ArmoredOutputStream armoredOutput = new ArmoredOutputStream(output);
    armoredOutput.beginClearText(digest);

    LineIterator iterator = new LineIterator(new InputStreamReader(input));

    while (iterator.hasNext()) {
        String line = iterator.nextLine();

        // trailing spaces must be removed for signature calculation (see http://tools.ietf.org/html/rfc4880#section-7.1)
        byte[] data = trim(line).getBytes("UTF-8");

        armoredOutput.write(data);
        armoredOutput.write(EOL);

        signatureGenerator.update(data);
        if (iterator.hasNext()) {
            signatureGenerator.update(EOL);
        }
    }

    armoredOutput.endClearText();

    PGPSignature signature = signatureGenerator.generate();
    signature.encode(new BCPGOutputStream(armoredOutput));

    armoredOutput.close();
}

From source file:org.m1theo.apt.repo.signing.PGPSigner.java

License:Apache License

/**
 * Creates a detached clear sign signature over the input data.
 *
 * @param input      the content to be signed
 * @param output     the output destination of the signature
 */// w  ww .j  ava2 s.  co m
public void clearSignDetached(InputStream input, OutputStream output)
        throws IOException, PGPException, GeneralSecurityException {

    PGPSignatureGenerator signatureGenerator = new PGPSignatureGenerator(
            new BcPGPContentSignerBuilder(privateKey.getPublicKeyPacket().getAlgorithm(), digest));
    signatureGenerator.init(PGPSignature.CANONICAL_TEXT_DOCUMENT, privateKey);

    ArmoredOutputStream armoredOutput = new ArmoredOutputStream(output);

    LineIterator iterator = new LineIterator(new InputStreamReader(input));

    while (iterator.hasNext()) {
        String line = iterator.nextLine();

        // trailing spaces must be removed for signature calculation (see http://tools.ietf.org/html/rfc4880#section-7.1)
        byte[] data = trim(line).getBytes("UTF-8");

        signatureGenerator.update(data);
        if (iterator.hasNext()) {
            signatureGenerator.update(EOL);
        }
    }

    PGPSignature signature = signatureGenerator.generate();
    signature.encode(new BCPGOutputStream(armoredOutput));

    armoredOutput.close();
}

From source file:org.sufficientlysecure.keychain.pgp.CanonicalizedSecretKey.java

License:Open Source License

public PGPSignatureGenerator getDataSignatureGenerator(int hashAlgo, boolean cleartext,
        Map<ByteBuffer, byte[]> signedHashes, Date creationTimestamp) throws PgpGeneralException {
    if (mPrivateKeyState == PRIVATE_KEY_STATE_LOCKED) {
        throw new PrivateKeyNotUnlockedException();
    }//from w ww.j a va2s.c o  m

    // We explicitly create a signature creation timestamp in this place.
    // That way, we can inject an artificial one from outside, ie the one
    // used in previous runs of this function.
    if (creationTimestamp == null) {
        // to sign using nfc PgpSignEncrypt is executed two times.
        // the first time it stops to return the PendingIntent for nfc connection and signing the hash
        // the second time the signed hash is used.
        // to get the same hash we cache the timestamp for the second round!
        creationTimestamp = new Date();
    }

    PGPContentSignerBuilder contentSignerBuilder = getContentSignerBuilder(hashAlgo, signedHashes);

    int signatureType;
    if (cleartext) {
        // for sign-only ascii text (cleartext signature)
        signatureType = PGPSignature.CANONICAL_TEXT_DOCUMENT;
    } else {
        signatureType = PGPSignature.BINARY_DOCUMENT;
    }

    try {
        PGPSignatureGenerator signatureGenerator = new PGPSignatureGenerator(contentSignerBuilder);
        signatureGenerator.init(signatureType, mPrivateKey);

        PGPSignatureSubpacketGenerator spGen = new PGPSignatureSubpacketGenerator();
        spGen.setSignerUserID(false, mRing.getPrimaryUserIdWithFallback());
        spGen.setSignatureCreationTime(false, creationTimestamp);
        signatureGenerator.setHashedSubpackets(spGen.generate());
        return signatureGenerator;
    } catch (PgpKeyNotFoundException | PGPException e) {
        // TODO: simply throw PGPException!
        throw new PgpGeneralException("Error initializing signature!", e);
    }
}

From source file:org.vafer.jdeb.signing.PGPSigner.java

License:Apache License

/**
 * Creates a clear sign signature over the input data. (Not detached)
 *
 * @param input      the content to be signed
 * @param output     the output destination of the signature
 *//*  w  ww.j a v a2s  .  c o  m*/
public void clearSign(InputStream input, OutputStream output)
        throws IOException, PGPException, GeneralSecurityException {
    int digest = PGPUtil.SHA1;

    PGPSignatureGenerator signatureGenerator = new PGPSignatureGenerator(
            new BcPGPContentSignerBuilder(privateKey.getPublicKeyPacket().getAlgorithm(), digest));
    signatureGenerator.init(PGPSignature.CANONICAL_TEXT_DOCUMENT, privateKey);

    ArmoredOutputStream armoredOutput = new ArmoredOutputStream(output);
    armoredOutput.beginClearText(digest);

    LineIterator iterator = new LineIterator(new InputStreamReader(input));

    while (iterator.hasNext()) {
        String line = iterator.nextLine();

        // trailing spaces must be removed for signature calculation (see http://tools.ietf.org/html/rfc4880#section-7.1)
        byte[] data = trim(line).getBytes("UTF-8");

        armoredOutput.write(data);
        armoredOutput.write(EOL);

        signatureGenerator.update(data);
        if (iterator.hasNext()) {
            signatureGenerator.update(EOL);
        }
    }

    armoredOutput.endClearText();

    PGPSignature signature = signatureGenerator.generate();
    signature.encode(new BCPGOutputStream(armoredOutput));

    armoredOutput.close();
}

From source file:org.vafer.jdeb.signing.SigningUtils.java

License:Apache License

/**
 * Create a clear sign signature over the input data. (Not detached)
 *
 * @param pInput//from  ww  w  .  j ava  2 s .  c  om
 * @param pKeyring
 * @param pKey
 * @param pPassphrase
 * @param pOutput
 * @throws IOException
 * @throws PGPException
 * @throws NoSuchProviderException
 * @throws NoSuchAlgorithmException
 * @throws SignatureException
 */
public static void clearSign(final InputStream pInput, final InputStream pKeyring, final String pKey,
        final String pPassphrase, final OutputStream pOutput) throws IOException, PGPException,
        NoSuchProviderException, NoSuchAlgorithmException, SignatureException {

    Security.addProvider(new BouncyCastleProvider());

    final PGPSecretKey secretKey = getSecretKey(pKeyring, pKey);
    final PGPPrivateKey privateKey = secretKey.extractPrivateKey(pPassphrase.toCharArray(), "BC");

    final int digest = PGPUtil.SHA1;

    final PGPSignatureGenerator signatureGenerator = new PGPSignatureGenerator(
            secretKey.getPublicKey().getAlgorithm(), digest, "BC");
    signatureGenerator.initSign(PGPSignature.CANONICAL_TEXT_DOCUMENT, privateKey);

    //        final PGPSignatureSubpacketGenerator subpackageGenerator = new PGPSignatureSubpacketGenerator();
    //
    //        final Iterator it = secretKey.getPublicKey().getUserIDs();
    //        if (it.hasNext()) {
    //            subpackageGenerator.setSignerUserID(false, (String)it.next());
    //            signatureGenerator.setHashedSubpackets(subpackageGenerator.generate());
    //        }

    final ArmoredOutputStream armoredOutput = new ArmoredOutputStream(pOutput);

    armoredOutput.beginClearText(digest);

    final BufferedReader reader = new BufferedReader(new InputStreamReader(pInput));

    final byte[] newline = "\r\n".getBytes("UTF-8");

    processLine(reader.readLine(), armoredOutput, signatureGenerator);

    while (true) {
        final String line = reader.readLine();

        if (line == null) {
            armoredOutput.write(newline);
            break;
        }

        armoredOutput.write(newline);
        signatureGenerator.update(newline);

        processLine(line, armoredOutput, signatureGenerator);
    }

    armoredOutput.endClearText();

    final BCPGOutputStream pgpOutput = new BCPGOutputStream(armoredOutput);

    signatureGenerator.generate().encode(pgpOutput);

    armoredOutput.close();

}