<p>
The parameters that are available for use by an AWS Signer user.
</p>

@param signingParameters
The parameters that are available for use by an AWS Signer user.
@return Returns a reference to this object so that method calls can be chained together.
976127
public SigningProfile withSigningParameters(java.util.Map<String, String> signingParameters) {
        setSigningParameters(signingParameters);
        return this;
    }
365699
public static Map<String, String> buildSignAfterParasMap(Map<String, String> params, String paternerKey) {
		params.put("nonce_str", String.valueOf(System.currentTimeMillis()));
		String sign = PaymentKit.createSign(params, paternerKey);
		params.put("sign", sign);
		return params;
	}
376597
public <T extends AbstractPutObjectRequest> T withSSEAwsKeyManagementParams(
            SSEAwsKeyManagementParams sseAwsKeyManagementParams) {
        setSSEAwsKeyManagementParams(sseAwsKeyManagementParams);
        @SuppressWarnings("unchecked") T t = (T)this;
        return t;
    }
428419
@SneakyThrows
    protected SignatureSigningParameters buildSignatureSigningParameters(final RoleDescriptor descriptor,
                                                                         final SamlRegisteredService service) {
        val criteria = new CriteriaSet();
        val signatureSigningConfiguration = getSignatureSigningConfiguration(descriptor, service);
        criteria.add(new SignatureSigningConfigurationCriterion(signatureSigningConfiguration));
        criteria.add(new RoleDescriptorCriterion(descriptor));
        val resolver = new SAMLMetadataSignatureSigningParametersResolver();
        LOGGER.trace("Resolving signature signing parameters for [{}]", descriptor.getElementQName().getLocalPart());
        val params = resolver.resolveSingle(criteria);
        if (params != null) {
            LOGGER.trace("Created signature signing parameters."
                            + "\nSignature algorithm: [{}]"
                            + "\nSignature canonicalization algorithm: [{}]"
                            + "\nSignature reference digest methods: [{}]",
                    params.getSignatureAlgorithm(),
                    params.getSignatureCanonicalizationAlgorithm(),
                    params.getSignatureReferenceDigestMethod());
        } else {
            LOGGER.warn("Unable to resolve SignatureSigningParameters, response signing will fail."
                    + " Make sure domain names in IDP metadata URLs and certificates match CAS domain name");
        }
        return params;
    }
405081
protected <T extends SAMLObject> void prepareSecurityParametersContext(final SamlRegisteredServiceServiceProviderMetadataFacade adaptor,
                                                                           final MessageContext<T> outboundContext,
                                                                           final SamlRegisteredService service) {
        val secParametersContext = outboundContext.getSubcontext(SecurityParametersContext.class, true);
        val roleDesc = adaptor.getSsoDescriptor();
        val signingParameters = buildSignatureSigningParameters(roleDesc, service);
        secParametersContext.setSignatureSigningParameters(signingParameters);
    }
23472
public OAuthParameters createParameters() {
    OAuthParameters result = new OAuthParameters();
    result.consumerKey = consumerKey;
    result.signer = signer;
    return result;
  }
184074
public KeyVerifyParameters withSignature(byte[] signature) {
        if (signature == null) {
            this.signature = null;
        } else {
            this.signature = Base64Url.encode(signature);
        }
        return this;
    }
529994
private static Signer lookupAndCreateSigner(String serviceName, String regionName) {
        String signerType = lookUpSignerTypeByServiceAndRegion(serviceName, regionName);
        return createSigner(signerType, serviceName);
    }
67845
private CodeSigner[] getSigners(SignerInfo infos[], PKCS7 block)
        throws IOException, NoSuchAlgorithmException, SignatureException,
            CertificateException {

        ArrayList<CodeSigner> signers = null;

        for (int i = 0; i < infos.length; i++) {

            SignerInfo info = infos[i];
            ArrayList<X509Certificate> chain = info.getCertificateChain(block);
            CertPath certChain = certificateFactory.generateCertPath(chain);
            if (signers == null) {
                signers = new ArrayList<CodeSigner>();
            }
            // Append the new code signer
            signers.add(new CodeSigner(certChain, getTimestamp(info)));

            if (debug != null) {
                debug.println("Signature Block Certificate: " +
                    chain.get(0));
            }
        }

        if (signers != null) {
            return signers.toArray(new CodeSigner[signers.size()]);
        } else {
            return null;
        }
    }
134423
protected byte[] newSigningKey(AWSCredentials credentials,
            String dateStamp, String regionName, String serviceName) {
        byte[] kSecret = ("AWS4" + credentials.getAWSSecretKey())
                .getBytes(Charset.forName("UTF-8"));
        byte[] kDate = sign(dateStamp, kSecret, SigningAlgorithm.HmacSHA256);
        byte[] kRegion = sign(regionName, kDate, SigningAlgorithm.HmacSHA256);
        byte[] kService = sign(serviceName, kRegion,
                SigningAlgorithm.HmacSHA256);
        return sign(AWS4_TERMINATOR, kService, SigningAlgorithm.HmacSHA256);
    }
776800
public java.util.List<ParameterMetadata> getParameters() {
        if (parameters == null) {
            parameters = new com.amazonaws.internal.SdkInternalList<ParameterMetadata>();
        }
        return parameters;
    }
124943
protected org.bouncycastle.crypto.CipherParameters getBcCipherParameter(AsymmetricCipherParameters parameters)
    {
        if (parameters instanceof BcAsymmetricKeyParameters) {
            return ((BcAsymmetricKeyParameters) parameters).getParameters();
        }

        // TODO: convert parameters to compatible ones
        throw new UnsupportedOperationException("Cipher parameters are incompatible with this signer: "
            + parameters.getClass().getName());
    }
225156
protected boolean parametersAreAdequate(Map<String, String> oauthParams) {
    return oauthParams.containsKey(OAuthConsumerParameter.oauth_consumer_key.toString());
  }
358133
private HashMap<String, String> createRegistrationParams() {
        registrationKeyPair = KeyPairUtility.generateRandomKeyPair();

        JSONObject csrJSON = new JSONObject();
        HashMap<String, String> params;

        try {
            DeviceIdentity deviceData = new BaseDeviceIdentity(preferences.deviceIdentity.getAsMap());
            AppIdentity applicationData = new BaseAppIdentity(preferences.appIdentity.getAsMap());

            csrJSON.put("deviceId", deviceData.getId());
            csrJSON.put("deviceOs", "" + deviceData.getOS());
            csrJSON.put("deviceModel", deviceData.getModel());
            csrJSON.put("applicationId", applicationData.getId());
            csrJSON.put("applicationVersion", applicationData.getVersion());
            csrJSON.put("environment", "android");

            String csrValue = jsonSigner.sign(registrationKeyPair, csrJSON);

            params = new HashMap<>(1);
            params.put("CSR", csrValue);

            return params;
        } catch (Exception e) {
            throw new RuntimeException("Failed to create registration params", e);
        }
    }
1030489
public byte[] getUpdateChannelConfigurationSignature(UpdateChannelConfiguration updateChannelConfiguration,
                                                         User signer) throws InvalidArgumentException {

        clientCheck();

        Channel systemChannel = Channel.newSystemChannel(this);
        return systemChannel.getUpdateChannelConfigurationSignature(updateChannelConfiguration, signer);

    }
282496
private List<NameValuePair> sign(URI uri, final List<NameValuePair> params)
    {
        Preconditions.checkNotNull(m_secret);

        final List<NameValuePair> sortedParams = Lists.newArrayList(params);
        Collections.sort(sortedParams, new Comparator<NameValuePair>() {
            @Override
            public int compare(NameValuePair left, NameValuePair right)
            {
                return left.getName().compareTo(right.getName());
            }
        });
        final StringBuilder paramSb = new StringBuilder();
        String separator = "";
        for (NameValuePair param : sortedParams) {
            paramSb.append(separator).append(param.getName());
            if (param.getValue() != null) {
                paramSb.append("=").append(param.getValue());
            }
            separator = "&";
        }

        final StringBuilder baseSb = new StringBuilder();
        baseSb.append(m_method).append('\n');
        baseSb.append(uri.getHost()).append('\n');
        baseSb.append(uri.getPath().isEmpty() ? '/' : uri.getPath()).append('\n');
        baseSb.append(paramSb.toString());

        final Mac hmac;
        final Key key;
        try {
            hmac = Mac.getInstance(m_signatureMethod);
            key = new SecretKeySpec(m_secret.getBytes(Charsets.UTF_8), m_signatureMethod);
            hmac.init(key);
        } catch (NoSuchAlgorithmException e) {
            // should never happen
            rateLimitedLogError(m_logger, "Fail to get HMAC instance %s", Throwables.getStackTraceAsString(e));
            return null;
        } catch (InvalidKeyException e) {
            rateLimitedLogError(m_logger, "Fail to sign the message %s", Throwables.getStackTraceAsString(e));
            return null;
        }

        sortedParams.add(new BasicNameValuePair(m_signatureName,
                NVPairsDecoder.percentEncode(Encoder.base64Encode(hmac.doFinal(baseSb.toString().getBytes(Charsets.UTF_8))))));
        return sortedParams;
    }
304764
@Override
    public SignatureVisitor visitParameterType() {
        if (type != METHOD_SIGNATURE
                || (state & (EMPTY | FORMAL | BOUND | PARAM)) == 0) {
            throw new IllegalArgumentException();
        }
        state = PARAM;
        SignatureVisitor v = sv == null ? null : sv.visitParameterType();
        return new CheckSignatureAdapter(TYPE_SIGNATURE, v);
    }