/** * Tries to register {@code manager} for the given {@code typeUrl}. If {@code newKeyAllowed} is * true, users can generate new keys with this manager using the {@link Registry#newKey} methods. * * <p>If there is an existing key manager, throw exception if {@code manager} and the existing * key manager aren't instances of the same class, and do nothing if they are. * * @throws GeneralSecurityException if there's an existing key manager is not an instance of the * class of {@code manager} * @deprecated use {@link #registerKeyManager(KeyManager<P>, boolean)} */ @Deprecated public static synchronized <P> void registerKeyManager( String typeUrl, final KeyManager<P> manager, boolean newKeyAllowed) throws GeneralSecurityException { if (manager == null) { throw new IllegalArgumentException("key manager must be non-null."); } if (!typeUrl.equals(manager.getKeyType())) { throw new GeneralSecurityException("Manager does not support key type " + typeUrl + "."); } registerKeyManager(manager, newKeyAllowed); }
/** * Convenience method for creating a new primitive for the key given in {@code proto}. * * <p>It looks up a {@link KeyManager} identified by {@code type_url}, and calls {@link * KeyManager#getPrimitive} with {@code serialized} as the parameter. * * @return a new primitive */ @SuppressWarnings("TypeParameterUnusedInFormals") public static <P> P getPrimitive(String typeUrl, ByteString serialized) throws GeneralSecurityException { KeyManager<P> manager = getKeyManager(typeUrl); return manager.getPrimitive(serialized); }
/** * @return a KeyManager for the given {@code typeUrl}, {@code primitiveName} and version at least * {@code minVersion} (if it exists in the catalogue). */ @Override public KeyManager<HybridDecrypt> getKeyManager( String typeUrl, String primitiveName, int minVersion) throws GeneralSecurityException { KeyManager<HybridDecrypt> keyManager; switch (primitiveName.toLowerCase()) { case "hybriddecrypt": keyManager = hybridDecryptKeyManager(typeUrl); break; default: throw new GeneralSecurityException( String.format("No support for primitive '%s'.", primitiveName)); } if (keyManager.getVersion() < minVersion) { throw new GeneralSecurityException( String.format( "No key manager for key type '%s' with version at least %d.", typeUrl, minVersion)); } return keyManager; }
if (key.getStatus() == KeyStatusType.ENABLED) { P primitive; if (customManager != null && customManager.doesSupport(key.getKeyData().getTypeUrl())) { primitive = customManager.getPrimitive(key.getKeyData().getValue()); } else { primitive = getPrimitive(key.getKeyData().getTypeUrl(), key.getKeyData().getValue());
/** * Convenience method for generating a new key for the specified {@code format}. * * <p>It looks up a {@link KeyManager} identified by {@code keyTemplate.type_url}, and calls * {@link KeyManager#newKey} with {@code format} as the parameter. * * @return a new key */ public static synchronized <P> MessageLite newKey(String typeUrl, MessageLite format) throws GeneralSecurityException { KeyManager<P> manager = getKeyManager(typeUrl); if (newKeyAllowedMap.get(typeUrl).booleanValue()) { return manager.newKey(format); } else { throw new GeneralSecurityException("newKey-operation not permitted for key type " + typeUrl); } }
/** * Convenience method for generating a new {@link KeyData} for the specified {@code template}. * * <p>It looks up a {@link KeyManager} identified by {@code keyTemplate.type_url}, and calls * {@link KeyManager#newKeyData}. * * <p>This method should be used solely for key management. * * @return a new {@link KeyData} */ public static synchronized <P> KeyData newKeyData(KeyTemplate keyTemplate) throws GeneralSecurityException { KeyManager<P> manager = getKeyManager(keyTemplate.getTypeUrl()); if (newKeyAllowedMap.get(keyTemplate.getTypeUrl()).booleanValue()) { return manager.newKeyData(keyTemplate.getValue()); } else { throw new GeneralSecurityException( "newKey-operation not permitted for key type " + keyTemplate.getTypeUrl()); } }
/** * Convenience method for generating a new key for the specified {@code keyTemplate}. * * <p>It looks up a {@link KeyManager} identified by {@code keyTemplate.type_url}, and calls * {@link KeyManager#newKey} with {@code keyTemplate} as the parameter. * * @return a new key */ public static synchronized <P> MessageLite newKey(KeyTemplate keyTemplate) throws GeneralSecurityException { KeyManager<P> manager = getKeyManager(keyTemplate.getTypeUrl()); if (newKeyAllowedMap.get(keyTemplate.getTypeUrl()).booleanValue()) { return manager.newKey(keyTemplate.getValue()); } else { throw new GeneralSecurityException( "newKey-operation not permitted for key type " + keyTemplate.getTypeUrl()); } }
/** * @return a KeyManager for the given {@code typeUrl}, {@code primitiveName} and version at least * {@code minVersion} (if it exists in the catalogue). */ @Override public KeyManager<Mac> getKeyManager(String typeUrl, String primitiveName, int minVersion) throws GeneralSecurityException { KeyManager<Mac> keyManager; switch (primitiveName.toLowerCase()) { case "mac": keyManager = macKeyManager(typeUrl); break; default: throw new GeneralSecurityException( String.format("No support for primitive '%s'.", primitiveName)); } if (keyManager.getVersion() < minVersion) { throw new GeneralSecurityException( String.format( "No key manager for key type '%s' with version at least %d.", typeUrl, minVersion)); } return keyManager; }
/** * Convenience method for creating a new primitive for the key given in {@code proto}. * * <p>It looks up a {@link KeyManager} identified by {@code type_url}, and calls {@link * KeyManager#getPrimitive} with {@code key} as the parameter. * * @return a new primitive */ @SuppressWarnings("TypeParameterUnusedInFormals") public static <P> P getPrimitive(String typeUrl, MessageLite key) throws GeneralSecurityException { KeyManager<P> manager = getKeyManager(typeUrl); return manager.getPrimitive(key); }
throw new IllegalArgumentException("key manager must be non-null."); String typeUrl = manager.getKeyType(); if (keyManagerMap.containsKey(typeUrl)) { KeyManager<P> existingManager = getKeyManager(typeUrl);
/** * @return a KeyManager for the given {@code typeUrl}, {@code primitiveName} and version at least * {@code minVersion} (if it exists in the catalogue). */ @Override public KeyManager<DeterministicAead> getKeyManager( String typeUrl, String primitiveName, int minVersion) throws GeneralSecurityException { KeyManager<DeterministicAead> keyManager; switch (primitiveName.toLowerCase()) { case "deterministicaead": keyManager = daeadKeyManager(typeUrl); break; default: throw new GeneralSecurityException( String.format("No support for primitive '%s'.", primitiveName)); } if (keyManager.getVersion() < minVersion) { throw new GeneralSecurityException( String.format( "No key manager for key type '%s' with version at least %d.", typeUrl, minVersion)); } return keyManager; }
/** * @return a KeyManager for the given {@code typeUrl}, {@code primitiveName} and version at least * {@code minVersion} (if it exists in the catalogue). */ @Override public KeyManager<PublicKeyVerify> getKeyManager( String typeUrl, String primitiveName, int minVersion) throws GeneralSecurityException { KeyManager<PublicKeyVerify> keyManager; switch (primitiveName.toLowerCase()) { case "publickeyverify": keyManager = publicKeyVerifyKeyManager(typeUrl); break; default: throw new GeneralSecurityException( String.format("No support for primitive '%s'.", primitiveName)); } if (keyManager.getVersion() < minVersion) { throw new GeneralSecurityException( String.format( "No key manager for key type '%s' with version at least %d.", typeUrl, minVersion)); } return keyManager; }
/** * @return a KeyManager for the given {@code typeUrl}, {@code primitiveName} and version at least * {@code minVersion} (if it exists in the catalogue). */ @Override public KeyManager<StreamingAead> getKeyManager( String typeUrl, String primitiveName, int minVersion) throws GeneralSecurityException { KeyManager<StreamingAead> keyManager; switch (primitiveName.toLowerCase()) { case "streamingaead": keyManager = streamingAeadKeyManager(typeUrl); break; default: throw new GeneralSecurityException( String.format("No support for primitive '%s'.", primitiveName)); } if (keyManager.getVersion() < minVersion) { throw new GeneralSecurityException( String.format( "No key manager for key type '%s' with version at least %d.", typeUrl, minVersion)); } return keyManager; }
/** * @return a KeyManager for the given {@code typeUrl}, {@code primitiveName} and version at least * {@code minVersion} (if it exists in the catalogue). */ @Override public KeyManager<Aead> getKeyManager(String typeUrl, String primitiveName, int minVersion) throws GeneralSecurityException { KeyManager<Aead> keyManager; switch (primitiveName.toLowerCase()) { case "aead": keyManager = aeadKeyManager(typeUrl); break; default: throw new GeneralSecurityException( String.format("No support for primitive '%s'.", primitiveName)); } if (keyManager.getVersion() < minVersion) { throw new GeneralSecurityException( String.format( "No key manager for key type '%s' with version at least %d.", typeUrl, minVersion)); } return keyManager; }
/** * @return a KeyManager for the given {@code typeUrl}, {@code primitiveName} and version at least * {@code minVersion} (if it exists in the catalogue). */ @Override public KeyManager<HybridEncrypt> getKeyManager( String typeUrl, String primitiveName, int minVersion) throws GeneralSecurityException { KeyManager<HybridEncrypt> keyManager; switch (primitiveName.toLowerCase()) { case "hybridencrypt": keyManager = hybridEncryptKeyManager(typeUrl); break; default: throw new GeneralSecurityException( String.format("No support for primitive '%s'.", primitiveName)); } if (keyManager.getVersion() < minVersion) { throw new GeneralSecurityException( String.format( "No key manager for key type '%s' with version at least %d.", typeUrl, minVersion)); } return keyManager; }
/** * @return a KeyManager for the given {@code typeUrl}, {@code primitiveName} and version at least * {@code minVersion} (if it exists in the catalogue). */ @Override public KeyManager<PublicKeySign> getKeyManager( String typeUrl, String primitiveName, int minVersion) throws GeneralSecurityException { KeyManager<PublicKeySign> keyManager; switch (primitiveName.toLowerCase()) { case "publickeysign": keyManager = publicKeySignKeyManager(typeUrl); break; default: throw new GeneralSecurityException( String.format("No support for primitive '%s'.", primitiveName)); } if (keyManager.getVersion() < minVersion) { throw new GeneralSecurityException( String.format( "No key manager for key type '%s' with version at least %d.", typeUrl, minVersion)); } return keyManager; }