<p>
The public keys used to verify the token signature.
</p>

@param tokenSigningPublicKeys
The public keys used to verify the token signature.
@return Returns a reference to this object so that method calls can be chained together.
172651
public UpdateAuthorizerRequest withTokenSigningPublicKeys(java.util.Map<String, String> tokenSigningPublicKeys) {
        setTokenSigningPublicKeys(tokenSigningPublicKeys);
        return this;
    }
690535
public PublicKey getPublicKey() {
        if (info == null)
            return null;
        try {
            PublicKey key = (PublicKey)info.get(CertificateX509Key.NAME
                                + DOT + CertificateX509Key.KEY);
            return key;
        } catch (Exception e) {
            return null;
        }
    }
79388
public static PrivateKey getSignCertPrivateKey() {
		try {
			Enumeration<String> aliasenum = keyStore.aliases();
			String keyAlias = null;
			if (aliasenum.hasMoreElements()) {
				keyAlias = aliasenum.nextElement();
			}
			PrivateKey privateKey = (PrivateKey) keyStore.getKey(keyAlias,
					SDKConfig.getConfig().getSignCertPwd().toCharArray());
			return privateKey;
		} catch (KeyStoreException e) {
			LogUtil.writeErrorLog("getSignCertPrivateKey Error", e);
			return null;
		} catch (UnrecoverableKeyException e) {
			LogUtil.writeErrorLog("getSignCertPrivateKey Error", e);
			return null;
		} catch (NoSuchAlgorithmException e) {
			LogUtil.writeErrorLog("getSignCertPrivateKey Error", e);
			return null;
		}
	}
655571
public String getPublicCertificateHash()
            throws CertificateEncodingException, NoSuchAlgorithmException {
        return Base64.encodeBase64String(AsymmetricKeyCredential
                .getHash(this.publicCertificate.getEncoded()));
    }
1044979
protected X509CertifiedPublicKey getPublicKey(CertifiedPublicKey publicKey)
    {
        if (publicKey instanceof X509CertifiedPublicKey) {
            return (X509CertifiedPublicKey) publicKey;
        }

        throw new IllegalArgumentException(String.format("Unsupported certificate [%s], expecting X509 certificates.",
            publicKey.getClass().getName()));
    }
525294
Key getPublicKey(String trustedAlias, String trustStoreRef, String signatureAlgorithm)
			throws KeyStoreServiceException, KeyException {
		Key signingKey = getPublicKeyFromKeystore(trustedAlias, trustStoreRef, signatureAlgorithm);
		if (tc.isDebugEnabled()) {
			Tr.debug(tc, "Trusted alias: " + trustedAlias + ", Truststore: " + trustStoreRef);
			Tr.debug(tc, "RSAPublicKey: " + (signingKey instanceof RSAPublicKey));
		}
		if (signingKey != null && !(signingKey instanceof RSAPublicKey)) {
			signingKey = null;
		}
		return signingKey;
	}
635564
static ECDSAKeyProvider providerForKeys(final ECPublicKey publicKey, final ECPrivateKey privateKey) {
        if (publicKey == null && privateKey == null) {
            throw new IllegalArgumentException("Both provided Keys cannot be null.");
        }
        return new ECDSAKeyProvider() {
            @Override
            public ECPublicKey getPublicKeyById(String keyId) {
                return publicKey;
            }

            @Override
            public ECPrivateKey getPrivateKey() {
                return privateKey;
            }

            @Override
            public String getPrivateKeyId() {
                return null;
            }
        };
    }
579449
public Map<String, String> getAllAdditionalPublicanCfgs() {
        final Map<String, String> retValue = new HashMap<String, String>();

        for (final Map.Entry<String, KeyValueNode<String>> entry : publicanCfgs.entrySet()) {
            if (!DEFAULT_PUBLICAN_CFG_KEY.equals(entry.getKey())) {
                retValue.put(entry.getValue().getKey(), entry.getValue().getValueText());
            }
        }

        return retValue;
    }
468263
public boolean signVerify(byte[] content,byte[] sign,PublicKey pubKey)  
    {  
        try   
        {  
            java.security.Signature signature = java.security.Signature.getInstance(SIGN_ALGORITHMS);  
            signature.initVerify(pubKey);  
            signature.update(content);  
            return signature.verify(sign);  
        }catch (Exception e)   
        {  
            log.error(e.getMessage(),e);
        }  
        return false;  
    }
849274
public Collection<String> getIdentifiers() {
    List<String> keys = new LinkedList<String>();
    keys.addAll(this.stateMap.keySet());
    return keys;
  }
527962
public boolean verify(byte[] message, byte[] signature) {
		try {
			// this way signatureInstance should be thread safe
			final Signature signatureInstance = ((provider == null) || (provider.length() == 0)) ? Signature
					.getInstance(algorithm) : Signature.getInstance(algorithm, provider);
			signatureInstance.initVerify(publicKey);
			signatureInstance.update(message);
			return signatureInstance.verify(signature);
		} catch (java.security.SignatureException e) {
			return false;
		} catch (Exception e) {
			throw new SignatureException("error verifying signature", e);
		}
	}
102163
def verifySignature(ecPublicSigningKey, message, signature):
        

        if ecPublicSigningKey.getType() == Curve.DJB_TYPE:
            result = _curve.verifySignature(ecPublicSigningKey.getPublicKey(), message, signature)
            return result == 0
        else:
            raise InvalidKeyException("Unknown type: %s" % ecPublicSigningKey.getType())
146906
private static PublicKey commonGetPublickeyByText(String keyText)
            throws NoSuchAlgorithmException, InvalidKeySpecException {
        byte[] keyBytes = Base64.base64ToByteArray(keyText);
        X509EncodedKeySpec x509KeySpec = new X509EncodedKeySpec(keyBytes);
        KeyFactory keyFactory = KeyFactory.getInstance(RSA);
        return keyFactory.generatePublic(x509KeySpec);
    }
11666
public java.util.List<SSHPublicKeyMetadata> getSSHPublicKeys() {
        if (sSHPublicKeys == null) {
            sSHPublicKeys = new com.amazonaws.internal.SdkInternalList<SSHPublicKeyMetadata>();
        }
        return sSHPublicKeys;
    }
690734
public static PublicKey readPublicKey(InputStream pemStream) {
		final Certificate certificate = KeyUtil.readX509Certificate(pemStream);
		if(null == certificate) {
			return null;
		}
		return certificate.getPublicKey();
	}
1342267
private PublicKey getRSAPublicKey(Provider provider) {

        try {
            RSAPublicKeySpec publicKeySpec = getRSAPublicKeySpec();
            KeyFactory factory = provider != null ? KeyFactory.getInstance("RSA", provider)
                    : KeyFactory.getInstance("RSA");

            return factory.generatePublic(publicKeySpec);
        } catch (GeneralSecurityException e) {
            throw new IllegalStateException(e);
        }
    }
1063506
function( keys ) {
		var lookupString = keys.toString();
		var id = this.plainObjectSignatureLookup[lookupString];			
		if (id === undefined) {

			// Create new signature buffer
			var sigbuf = [];
			sigbuf.push( pack2b( keys.length, false ) );
			for (var i=0, l=keys.length; i<l; ++i) {
				sigbuf.push( pack2b( this.stringID(keys[i]), false ) );
			}

			// Keep on table
			this.plainObjectSignatureTable.push( Buffer.concat( sigbuf ) );
			this.plainObjectSignatureLookup[lookupString] 
				= id = this.plainObjectSignatureTable.length - 1;

		}
		return id;
	}