| /* |
| * Licensed to the Apache Software Foundation (ASF) under one |
| * or more contributor license agreements. See the NOTICE file |
| * distributed with this work for additional information |
| * regarding copyright ownership. The ASF licenses this file |
| * to you under the Apache License, Version 2.0 (the |
| * "License"); you may not use this file except in compliance |
| * with the License. You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, |
| * software distributed under the License is distributed on an |
| * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY |
| * KIND, either express or implied. See the License for the |
| * specific language governing permissions and limitations |
| * under the License. |
| */ |
| |
| package org.apache.sshd.openpgp; |
| |
| import java.nio.file.Path; |
| import java.util.Collection; |
| import java.util.Collections; |
| import java.util.EnumSet; |
| import java.util.NavigableMap; |
| import java.util.Set; |
| import java.util.TreeMap; |
| import java.util.concurrent.atomic.AtomicReference; |
| import java.util.function.Supplier; |
| |
| import org.apache.sshd.common.PropertyResolverUtils; |
| import org.apache.sshd.common.util.GenericUtils; |
| import org.apache.sshd.common.util.OsUtils; |
| import org.apache.sshd.common.util.ValidateUtils; |
| import org.apache.sshd.common.util.io.PathUtils; |
| import org.c02e.jpgpj.CompressionAlgorithm; |
| import org.c02e.jpgpj.EncryptionAlgorithm; |
| import org.c02e.jpgpj.Key; |
| import org.c02e.jpgpj.Subkey; |
| |
| /** |
| * TODO Add javadoc |
| * |
| * @author <a href="mailto:dev@mina.apache.org">Apache MINA SSHD Project</a> |
| */ |
| public final class PGPUtils { |
| public static final String DEFAULT_PGP_FILE_SUFFIX = ".gpg"; |
| |
| public static final String STD_LINUX_PGP_FOLDER_NAME = ".gnupg"; |
| public static final String STD_WINDOWS_PGP_FOLDER_NAME = "gnupg"; |
| |
| /** Default MIME type for PGP encrypted files */ |
| public static final String PGP_ENCRYPTED_FILE = "application/pgp-encrypted"; |
| |
| /** Alias for {@link EncryptionAlgorithm#Unencrypted Unencrypted} */ |
| public static final String NO_CIPHER_PLACEHOLDER = PropertyResolverUtils.NONE_VALUE; |
| |
| public static final Set<EncryptionAlgorithm> CIPHERS |
| = Collections.unmodifiableSet(EnumSet.allOf(EncryptionAlgorithm.class)); |
| |
| /** Alias for {@link CompressionAlgorithm#Uncompressed Uncompressed} */ |
| public static final String NO_COMPRESSION_PLACEHOLDER = PropertyResolverUtils.NONE_VALUE; |
| |
| public static final Set<CompressionAlgorithm> COMPRESSIONS |
| = Collections.unmodifiableSet(EnumSet.allOf(CompressionAlgorithm.class)); |
| |
| private static final AtomicReference<Supplier<? extends Path>> DEFAULT_PGP_PATH_RESOLVER_HOLDER = new AtomicReference<>(); |
| |
| private PGPUtils() { |
| throw new UnsupportedOperationException("No instance"); |
| } |
| |
| public static EncryptionAlgorithm fromCipherName(String name) { |
| if (GenericUtils.isEmpty(name)) { |
| return null; |
| } |
| |
| if (NO_CIPHER_PLACEHOLDER.equalsIgnoreCase(name)) { |
| return EncryptionAlgorithm.Unencrypted; |
| } |
| |
| return CIPHERS.stream() |
| .filter(c -> name.equalsIgnoreCase(c.name())) |
| .findFirst() |
| .orElse(null); |
| } |
| |
| public static CompressionAlgorithm fromCompressionName(String name) { |
| if (GenericUtils.isEmpty(name)) { |
| return null; |
| } |
| |
| if (NO_COMPRESSION_PLACEHOLDER.equalsIgnoreCase(name)) { |
| return CompressionAlgorithm.Uncompressed; |
| } else { |
| return COMPRESSIONS.stream() |
| .filter(c -> name.equalsIgnoreCase(c.name())) |
| .findFirst() |
| .orElse(null); |
| } |
| } |
| |
| /** |
| * @param key The {@link Key} whose sub-keys to map - ignored if {@code null} or no sub-keys |
| * available |
| * @return A {@link NavigableMap} where key=the (case <U>insensitive</U>) fingerprint |
| * value, value=the matching {@link Subkey} |
| * @throws NullPointerException If key with {@code null} fingerprint encountered |
| * @throws IllegalArgumentException If key with empty fingerprint encountered |
| * @throws IllegalStateException If more than one key with same fingerprint found |
| * @see #mapSubKeysByFingerprint(Collection) |
| */ |
| public static NavigableMap<String, Subkey> mapSubKeysByFingerprint(Key key) { |
| return mapSubKeysByFingerprint((key == null) ? Collections.emptyList() : key.getSubkeys()); |
| } |
| |
| /** |
| * @param subKeys The {@link Subkey}-s to map - ignored if {@code null}/empty |
| * @return A {@link NavigableMap} where key=the (case <U>insensitive</U>) fingerprint |
| * value, value=the matching {@link Subkey} |
| * @throws NullPointerException If key with {@code null} fingerprint encountered |
| * @throws IllegalArgumentException If key with empty fingerprint encountered |
| * @throws IllegalStateException If more than one key with same fingerprint found |
| */ |
| public static NavigableMap<String, Subkey> mapSubKeysByFingerprint(Collection<? extends Subkey> subKeys) { |
| if (GenericUtils.isEmpty(subKeys)) { |
| return Collections.emptyNavigableMap(); |
| } |
| |
| NavigableMap<String, Subkey> keysMap = new TreeMap<>(String.CASE_INSENSITIVE_ORDER); |
| for (Subkey sk : subKeys) { |
| String fp = ValidateUtils.checkNotNullAndNotEmpty(sk.getFingerprint(), "No fingerprint for %s", sk); |
| Subkey prev = keysMap.put(fp, sk); |
| ValidateUtils.checkState(prev == null, "Multiple sub-keys with fingerprint=%s: %s / %s", fp, sk, prev); |
| } |
| |
| return keysMap; |
| } |
| |
| /** |
| * @param key The {@link Key} whose sub-keys to scan - ignored if {@code null} or has no sub-keys |
| * @param fingerprint The fingerprint to match (case <U>insensitive</U>) - ignored if {@code null}/empty |
| * @return The first matching {@link Subkey} - {@code null} if no match found |
| * @see #findSubkeyByFingerprint(Collection, String) |
| */ |
| public static Subkey findSubkeyByFingerprint(Key key, String fingerprint) { |
| return findSubkeyByFingerprint((key == null) ? Collections.emptyList() : key.getSubkeys(), fingerprint); |
| } |
| |
| /** |
| * @param subKeys The {@link Subkey}-s to scan - ignored if {@code null}/empty |
| * @param fingerprint The fingerprint to match (case <U>insensitive</U>) - ignored if {@code null}/empty |
| * @return The first matching sub-key - {@code null} if no match found |
| */ |
| public static Subkey findSubkeyByFingerprint(Collection<? extends Subkey> subKeys, String fingerprint) { |
| if (GenericUtils.isEmpty(subKeys) || GenericUtils.isEmpty(fingerprint)) { |
| return null; |
| } |
| |
| return subKeys.stream() |
| .filter(k -> fingerprint.equalsIgnoreCase(k.getFingerprint())) |
| .findFirst() |
| .orElse(null); |
| } |
| |
| private static final class LazyDefaultPgpKeysFolderHolder { |
| private static final Path PATH = PathUtils.getUserHomeFolder() |
| .resolve(OsUtils.isWin32() ? STD_WINDOWS_PGP_FOLDER_NAME : STD_LINUX_PGP_FOLDER_NAME); |
| |
| private LazyDefaultPgpKeysFolderHolder() { |
| throw new UnsupportedOperationException("No instance allowed"); |
| } |
| } |
| |
| /** |
| * @return The default <A HREF="https://www.gnupg.org/">Gnu Privacy Guard</A> folder used to hold key files. |
| */ |
| @SuppressWarnings("synthetic-access") |
| public static Path getDefaultPgpFolderPath() { |
| Supplier<? extends Path> resolver; |
| synchronized (DEFAULT_PGP_PATH_RESOLVER_HOLDER) { |
| resolver = DEFAULT_PGP_PATH_RESOLVER_HOLDER.get(); |
| } |
| |
| return (resolver == null) ? LazyDefaultPgpKeysFolderHolder.PATH : resolver.get(); |
| } |
| |
| /** |
| * Set the reported value from {@link #getDefaultPgpFolderPath()} |
| * |
| * @param resolver The {@link Path} provider to report - if {@code null} then O/S default value will be used |
| */ |
| public static void setDefaultPgpFolderPathResolver(Supplier<? extends Path> resolver) { |
| synchronized (DEFAULT_PGP_PATH_RESOLVER_HOLDER) { |
| DEFAULT_PGP_PATH_RESOLVER_HOLDER.set(resolver); |
| } |
| } |
| } |
