package org.springframework.roo.felix.pgp;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.MalformedURLException;
import java.net.URL;
import java.security.Security;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.Iterator;
import java.util.List;
import java.util.SortedMap;
import java.util.SortedSet;
import java.util.TreeMap;
import java.util.TreeSet;
import org.apache.commons.io.FileUtils;
import org.apache.commons.io.IOUtils;
import org.apache.commons.lang3.ObjectUtils;
import org.apache.commons.lang3.StringUtils;
import org.apache.commons.lang3.Validate;
import org.apache.commons.lang3.exception.ExceptionUtils;
import org.apache.felix.scr.annotations.Component;
import org.apache.felix.scr.annotations.Reference;
import org.apache.felix.scr.annotations.Service;
import org.bouncycastle.bcpg.ArmoredInputStream;
import org.bouncycastle.jce.provider.BouncyCastleProvider;
import org.bouncycastle.openpgp.PGPCompressedData;
import org.bouncycastle.openpgp.PGPObjectFactory;
import org.bouncycastle.openpgp.PGPPublicKey;
import org.bouncycastle.openpgp.PGPPublicKeyRing;
import org.bouncycastle.openpgp.PGPPublicKeyRingCollection;
import org.bouncycastle.openpgp.PGPSignature;
import org.bouncycastle.openpgp.PGPSignatureList;
import org.bouncycastle.openpgp.PGPUtil;
import org.osgi.framework.BundleContext;
import org.osgi.service.component.ComponentContext;
import org.springframework.roo.support.osgi.OSGiUtils;
import org.springframework.roo.url.stream.UrlInputStreamService;
/**
* Default implementation of {@link PgpService}.
* <p>
* Stores the user's PGP information in the
* <code>~/.spring_roo_pgp.bpg<code> file. Every key in this
* file is considered trusted by the user. Expiration times of keys are ignored. Default keys that
* ship with Roo are added to this file automatically when the file is not present on disk.
*
* <p>
* This implementation will only verify "detached armored signatures". Produce such a file via
* "gpg --armor --detach-sign file_to_sign.ext".
*
* @author Ben Alex
* @since 1.1
*/
@Component
@Service
public class PgpServiceImpl implements PgpService {
private static final int BUFFER_SIZE = 1024;
private static String defaultKeyServerUrl = "http://keyserver.ubuntu.com/pks/lookup?op=get&search=";
// private static String defaultKeyServerUrl =
// "http://pgp.mit.edu/pks/lookup?op=get&search=";
private static final File ROO_PGP_FILE = FileUtils.getFile(
FileUtils.getUserDirectory(), ".spring_roo_pgp.bpg");
static {
Security.addProvider(new BouncyCastleProvider());
}
private boolean automaticTrust;
private BundleContext context;
private final SortedSet<PgpKeyId> discoveredKeyIds = new TreeSet<PgpKeyId>();
@Reference private UrlInputStreamService urlInputStreamService;
public SortedSet<PgpKeyId> getDiscoveredKeyIds() {
return Collections.unmodifiableSortedSet(discoveredKeyIds);
}
public URL getKeyServerUrlToRetrieveKeyInformation(final PgpKeyId keyId) {
Validate.notNull(keyId, "Key ID required");
final URL keyUrl = getKeyServerUrlToRetrieveKeyId(keyId);
try {
final URL keyIndexUrl = new URL(keyUrl.getProtocol() + "://"
+ keyUrl.getAuthority() + keyUrl.getPath()
+ "?fingerprint=on&op=index&search=");
return new URL(keyIndexUrl.toString() + keyId);
}
catch (final MalformedURLException e) {
throw new IllegalStateException(e);
}
}
public String getKeyStorePhysicalLocation() {
try {
return ROO_PGP_FILE.getCanonicalPath();
}
catch (final IOException e) {
throw new IllegalStateException(e);
}
}
public PGPPublicKeyRing getPublicKey(final InputStream in) {
Object obj;
try {
final PGPObjectFactory pgpFact = new PGPObjectFactory(
PGPUtil.getDecoderStream(in));
obj = pgpFact.nextObject();
}
catch (final Exception e) {
throw new IllegalStateException(e);
}
if (obj instanceof PGPPublicKeyRing) {
final PGPPublicKeyRing keyRing = (PGPPublicKeyRing) obj;
rememberKey(keyRing);
return keyRing;
}
throw new IllegalStateException("Pblic key not available");
}
public PGPPublicKeyRing getPublicKey(final PgpKeyId keyId) {
Validate.notNull(keyId, "Key ID required");
InputStream in = null;
try {
final URL lookup = getKeyServerUrlToRetrieveKeyId(keyId);
in = urlInputStreamService.openConnection(lookup);
return getPublicKey(in);
}
catch (final Exception e) {
throw new IllegalStateException("Public key ID '" + keyId
+ "' not available from key server", e);
}
finally {
IOUtils.closeQuietly(in);
}
}
@SuppressWarnings("unchecked")
public List<PGPPublicKeyRing> getTrustedKeys() {
if (!ROO_PGP_FILE.exists()) {
return new ArrayList<PGPPublicKeyRing>();
}
FileInputStream fis = null;
try {
fis = new FileInputStream(ROO_PGP_FILE);
final PGPPublicKeyRingCollection pubRings = new PGPPublicKeyRingCollection(
PGPUtil.getDecoderStream(fis));
final Iterator<PGPPublicKeyRing> rIt = pubRings.getKeyRings();
final List<PGPPublicKeyRing> result = new ArrayList<PGPPublicKeyRing>();
while (rIt.hasNext()) {
final PGPPublicKeyRing pgpPub = rIt.next();
rememberKey(pgpPub);
result.add(pgpPub);
}
return result;
}
catch (final Exception e) {
throw new IllegalArgumentException(
"Unable to get trusted keys",
ObjectUtils.defaultIfNull(ExceptionUtils.getRootCause(e), e));
}
finally {
IOUtils.closeQuietly(fis);
}
}
public boolean isAutomaticTrust() {
return automaticTrust;
}
public boolean isResourceSignedBySignature(final InputStream resource,
InputStream signature) {
PGPPublicKey publicKey = null;
PGPSignature pgpSignature = null;
try {
if (!(signature instanceof ArmoredInputStream)) {
signature = new ArmoredInputStream(signature);
}
pgpSignature = isSignatureAcceptable(signature).getPgpSignature();
final PGPPublicKeyRing keyRing = getPublicKey(new PgpKeyId(
pgpSignature));
rememberKey(keyRing);
publicKey = keyRing.getPublicKey();
Validate.notNull(publicKey,
"Could not obtain public key for signer key ID '%s'",
pgpSignature);
pgpSignature.initVerify(publicKey, "BC");
// Now verify the signed content
final byte[] buff = new byte[BUFFER_SIZE];
int chunk;
do {
chunk = resource.read(buff);
if (chunk > 0) {
pgpSignature.update(buff, 0, chunk);
}
} while (chunk >= 0);
return pgpSignature.verify();
}
catch (final Exception e) {
throw new IllegalStateException(e);
}
}
public SignatureDecision isSignatureAcceptable(final InputStream signature)
throws IOException {
Validate.notNull(signature, "Signature input stream required");
PGPObjectFactory factory = new PGPObjectFactory(
PGPUtil.getDecoderStream(signature));
final Object obj = factory.nextObject();
Validate.notNull(obj, "Unable to retrieve signature from stream");
PGPSignatureList p3;
if (obj instanceof PGPCompressedData) {
try {
factory = new PGPObjectFactory(
((PGPCompressedData) obj).getDataStream());
}
catch (final Exception e) {
throw new IllegalStateException(e);
}
p3 = (PGPSignatureList) factory.nextObject();
}
else {
p3 = (PGPSignatureList) obj;
}
final PGPSignature pgpSignature = p3.get(0);
Validate.notNull(pgpSignature,
"Unable to retrieve signature from stream");
final PgpKeyId keyIdInHex = new PgpKeyId(pgpSignature);
// Special case where we directly store the key ID, as we know it's
// valid
discoveredKeyIds.add(keyIdInHex);
boolean signatureAcceptable = false;
// Loop to see if the user trusts this key
for (final PGPPublicKeyRing keyRing : getTrustedKeys()) {
final PgpKeyId candidate = new PgpKeyId(keyRing.getPublicKey());
if (candidate.equals(keyIdInHex)) {
signatureAcceptable = true;
break;
}
}
if (!signatureAcceptable && automaticTrust) {
// We don't approve of this signature, but the user has told us it's
// OK
trust(keyIdInHex);
signatureAcceptable = true;
}
return new SignatureDecision(pgpSignature, keyIdInHex,
signatureAcceptable);
}
public SortedMap<PgpKeyId, String> refresh() {
final SortedMap<PgpKeyId, String> result = new TreeMap<PgpKeyId, String>();
// Get the keys we currently trust
final List<PGPPublicKeyRing> trusted = getTrustedKeys();
// Build a new list of our refreshed keys
final List<PGPPublicKeyRing> stillTrusted = new ArrayList<PGPPublicKeyRing>();
// Locate the element to remove (we need to record it so the method can
// return it)
for (final PGPPublicKeyRing candidate : trusted) {
final PGPPublicKey firstKey = candidate.getPublicKey();
final PgpKeyId candidateKeyId = new PgpKeyId(firstKey);
// Try to refresh
PGPPublicKeyRing newKeyRing;
try {
newKeyRing = getPublicKey(candidateKeyId);
}
catch (final Exception e) {
// Can't retrieve, so keep the old one for now
stillTrusted.add(candidate);
result.put(candidateKeyId,
"WARNING: Retained original (download issue)");
continue;
}
// Do not store if the first key is revoked
if (newKeyRing.getPublicKey().isRevoked()) {
result.put(candidateKeyId,
"WARNING: Key revoked, so removed from trust list");
}
else {
stillTrusted.add(newKeyRing);
result.put(candidateKeyId, "SUCCESS");
}
}
// Write back to disk
OutputStream fos = null;
try {
final PGPPublicKeyRingCollection newCollection = new PGPPublicKeyRingCollection(
stillTrusted);
fos = new FileOutputStream(ROO_PGP_FILE);
newCollection.encode(fos);
}
catch (final Exception e) {
throw new IllegalStateException(e);
}
finally {
IOUtils.closeQuietly(fos);
}
return result;
}
public void setAutomaticTrust(final boolean automaticTrust) {
this.automaticTrust = automaticTrust;
}
public PGPPublicKeyRing trust(final PgpKeyId keyId) {
Validate.notNull(keyId, "Key ID required");
final PGPPublicKeyRing keyRing = getPublicKey(keyId);
return trust(keyRing);
}
@SuppressWarnings("unchecked")
public PGPPublicKeyRing untrust(final PgpKeyId keyId) {
Validate.notNull(keyId, "Key ID required");
// Get the keys we currently trust
final List<PGPPublicKeyRing> trusted = getTrustedKeys();
// Build a new list of keys we'll continue to trust after this method
// ends
final List<PGPPublicKeyRing> stillTrusted = new ArrayList<PGPPublicKeyRing>();
// Locate the element to remove (we need to record it so the method can
// return it)
PGPPublicKeyRing removed = null;
for (final PGPPublicKeyRing candidate : trusted) {
boolean stillTrust = true;
final Iterator<PGPPublicKey> it = candidate.getPublicKeys();
while (it.hasNext()) {
final PGPPublicKey pgpKey = it.next();
final PgpKeyId candidateKeyId = new PgpKeyId(pgpKey);
if (removed == null && candidateKeyId.equals(keyId)) {
stillTrust = false;
removed = candidate;
break;
}
}
if (stillTrust) {
stillTrusted.add(candidate);
}
}
Validate.notNull(removed,
"The public key ID '%s' is not currently trusted", keyId);
// Write back to disk
OutputStream fos = null;
try {
final PGPPublicKeyRingCollection newCollection = new PGPPublicKeyRingCollection(
stillTrusted);
fos = new FileOutputStream(ROO_PGP_FILE);
newCollection.encode(fos);
}
catch (final Exception e) {
throw new IllegalStateException(e);
}
finally {
IOUtils.closeQuietly(fos);
}
return removed;
}
protected void activate(final ComponentContext context) {
this.context = context.getBundleContext();
final String keyserver = context.getBundleContext().getProperty(
"pgp.keyserver.url");
if (StringUtils.isNotBlank(keyserver)) {
defaultKeyServerUrl = keyserver;
}
trustDefaultKeysIfRequired();
// Seed the discovered keys database
getTrustedKeys();
}
protected void trustDefaultKeysIfRequired() {
// Setup default keys we trust automatically
trustDefaultKeys();
}
/**
* Obtains a URL that should allow the download of the specified public key.
* <p>
* The key server may not contain the specified public key if it has never
* been uploaded.
*
* @param keyId hex-encoded key ID to download (required)
* @return the URL (never null)
*/
private URL getKeyServerUrlToRetrieveKeyId(final PgpKeyId keyId) {
try {
return new URL(defaultKeyServerUrl + keyId);
}
catch (final MalformedURLException e) {
throw new IllegalStateException(e);
}
}
/**
* Simply stores the key ID in {@link #discoveredKeyIds} for future
* reference of all Key IDs we've come across. This method uses a
* {@link PGPPublicKeyRing} to ensure the input is actually a valid key,
* plus locating any key IDs that have signed the key.
* <p>
* Please note {@link #discoveredKeyIds} is not used for any key functions
* of this class. It is simply for user interface convenience.
*
* @param keyRing the key ID to store (required)
*/
@SuppressWarnings("unchecked")
private void rememberKey(final PGPPublicKeyRing keyRing) {
final PGPPublicKey key = keyRing.getPublicKey();
if (key != null) {
final PgpKeyId keyId = new PgpKeyId(key);
discoveredKeyIds.add(keyId);
final Iterator<String> userIdIterator = key.getUserIDs();
while (userIdIterator.hasNext()) {
final String userId = userIdIterator.next();
final Iterator<PGPSignature> signatureIterator = key
.getSignaturesForID(userId);
while (signatureIterator.hasNext()) {
final PGPSignature signature = signatureIterator.next();
final PgpKeyId signatureKeyId = new PgpKeyId(signature);
discoveredKeyIds.add(signatureKeyId);
}
}
}
}
private PGPPublicKeyRing trust(final PGPPublicKeyRing keyRing) {
rememberKey(keyRing);
// Get the keys we currently trust
final List<PGPPublicKeyRing> trusted = getTrustedKeys();
// Do not store if the first key is revoked
Validate.validState(
!keyRing.getPublicKey().isRevoked(),
"The public key ID '%s' has been revoked and cannot be trusted",
new PgpKeyId(keyRing.getPublicKey()));
// trust it and write back to disk
trusted.add(keyRing);
OutputStream fos = null;
try {
final PGPPublicKeyRingCollection newCollection = new PGPPublicKeyRingCollection(
trusted);
fos = new FileOutputStream(ROO_PGP_FILE);
newCollection.encode(fos);
}
catch (final Exception e) {
throw new IllegalStateException(e);
}
finally {
IOUtils.closeQuietly(fos);
}
return keyRing;
}
private void trustDefaultKeys() {
// Get the URIs of all PGP keystore files within installed OSGi bundles
final List<URL> urls = new ArrayList<URL>(
OSGiUtils.findEntriesByPattern(context,
"/org/springframework/roo/felix/pgp/*.asc"));
Collections.sort(urls, new Comparator<URL>() {
public int compare(final URL url1, final URL url2) {
return url1.toExternalForm().compareTo(url2.toExternalForm());
}
});
// Trust each one
for (final URL url : urls) {
InputStream inputStream = null;
try {
inputStream = url.openStream();
trust(getPublicKey(inputStream));
}
catch (final IOException ignored) {
}
finally {
IOUtils.closeQuietly(inputStream);
}
}
}
}