Java ParametersWithRandom类代码示例

import org.bouncycastle.crypto.params.ParametersWithRandom; //导入依赖的package包/类
public byte[] generateRawSignature(SignatureAndHashAlgorithm algorithm,
    AsymmetricKeyParameter privateKey, byte[] hash)
    throws CryptoException
{
    Signer signer = makeSigner(algorithm, true, true,
        new ParametersWithRandom(privateKey, this.context.getSecureRandom()));
    if (algorithm == null)
    {
        // Note: Only use the SHA1 part of the (MD5/SHA1) hash
        signer.update(hash, 16, 20);
    }
    else
    {
        signer.update(hash, 0, hash.length);
    }
    return signer.generateSignature();
}
 

import org.bouncycastle.crypto.params.ParametersWithRandom; //导入依赖的package包/类
/**
 * initialise the cipher.
 *
 * @param forEncryption if true the cipher is initialised for
 *  encryption, if false for decryption.
 * @param params the key and other data required by the cipher.
 * @exception IllegalArgumentException if the params argument is
 * inappropriate.
 */
public void init(
    boolean             forEncryption,
    CipherParameters    params)
    throws IllegalArgumentException
{
    this.forEncryption = forEncryption;

    reset();

    if (params instanceof ParametersWithRandom)
    {
        ParametersWithRandom    p = (ParametersWithRandom)params;

        padding.init(p.getRandom());

        cipher.init(forEncryption, p.getParameters());
    }
    else
    {
        padding.init(null);

        cipher.init(forEncryption, params);
    }
}
 

import org.bouncycastle.crypto.params.ParametersWithRandom; //导入依赖的package包/类
public byte[] generateWrappedKey(GenericKey encryptionKey)
    throws OperatorException
{
    byte[] contentEncryptionKeySpec = OperatorUtils.getKeyBytes(encryptionKey);

    if (random == null)
    {
        wrapper.init(true, wrappingKey);
    }
    else
    {
        wrapper.init(true, new ParametersWithRandom(wrappingKey, random));
    }

    return wrapper.wrap(contentEncryptionKeySpec, 0, contentEncryptionKeySpec.length);
}
 

import org.bouncycastle.crypto.params.ParametersWithRandom; //导入依赖的package包/类
public void init(boolean forEncryption, CipherParameters parameters)
{
    this.forEncryption = forEncryption;
    if (forEncryption)
    {
        if (parameters instanceof ParametersWithRandom)
        {
            ParametersWithRandom p = (ParametersWithRandom)parameters;

            this.random = p.getRandom();
            this.pubKey = (NTRUEncryptionPublicKeyParameters)p.getParameters();
        }
        else
        {
            this.random = new SecureRandom();
            this.pubKey = (NTRUEncryptionPublicKeyParameters)parameters;
        }

        this.params = pubKey.getParameters();
    }
    else
    {
        this.privKey = (NTRUEncryptionPrivateKeyParameters)parameters;
        this.params = privKey.getParameters();
    }
}
 

import org.bouncycastle.crypto.params.ParametersWithRandom; //导入依赖的package包/类
public void init(
    boolean             forWrapping,
    CipherParameters    param)
{
    this.forWrapping = forWrapping;

    if (param instanceof ParametersWithRandom)
    {
        param = ((ParametersWithRandom) param).getParameters();
    }

    if (param instanceof KeyParameter)
    {
        this.param = (KeyParameter)param;
    }
    else if (param instanceof ParametersWithIV)
    {
        this.iv = ((ParametersWithIV)param).getIV();
        this.param = (KeyParameter)((ParametersWithIV) param).getParameters();
        if (this.iv.length != 8)
        {
           throw new IllegalArgumentException("IV not equal to 8");
        }
    }
}
 

import org.bouncycastle.crypto.params.ParametersWithRandom; //导入依赖的package包/类
public byte[] decryptPreMasterSecret(byte[] encryptedPreMasterSecret)
    throws IOException
{

    PKCS1Encoding encoding = new PKCS1Encoding(new RSABlindedEngine());
    encoding.init(false, new ParametersWithRandom(this.privateKey, context.getSecureRandom()));

    try
    {
        return encoding.processBlock(encryptedPreMasterSecret, 0,
            encryptedPreMasterSecret.length);
    }
    catch (InvalidCipherTextException e)
    {
        throw new TlsFatalAlert(AlertDescription.illegal_parameter);
    }
}
 

import org.bouncycastle.crypto.params.ParametersWithRandom; //导入依赖的package包/类
public void init(
    boolean             forEncryption,
    CipherParameters    param)
{
    if (param instanceof ParametersWithRandom)
    {
        ParametersWithRandom  rParam = (ParametersWithRandom)param;

        this.random = rParam.getRandom();
    }
    else
    {   
        this.random = new SecureRandom();
    }

    engine.init(forEncryption, param);

    this.forEncryption = forEncryption;
}
 

import org.bouncycastle.crypto.params.ParametersWithRandom; //导入依赖的package包/类
/**
 * initialise the EC Elgamal engine.
 *
 * @param param the necessary EC key parameters.
 */
public void init(
    CipherParameters    param)
{
    if (param instanceof ParametersWithRandom)
    {
        ParametersWithRandom    p = (ParametersWithRandom)param;

        if (!(p.getParameters() instanceof ECPublicKeyParameters))
        {
            throw new IllegalArgumentException("ECPublicKeyParameters are required for new public key transform.");
        }
        this.key = (ECPublicKeyParameters)p.getParameters();
        this.random = p.getRandom();
    }
    else
    {
        if (!(param instanceof ECPublicKeyParameters))
        {
            throw new IllegalArgumentException("ECPublicKeyParameters are required for new public key transform.");
        }

        this.key = (ECPublicKeyParameters)param;
        this.random = new SecureRandom();
    }
}
 

import org.bouncycastle.crypto.params.ParametersWithRandom; //导入依赖的package包/类
/**
 * initialise the encryptor.
 *
 * @param param the necessary EC key parameters.
 */
public void init(
    CipherParameters    param)
{
    if (param instanceof ParametersWithRandom)
    {
        ParametersWithRandom    p = (ParametersWithRandom)param;

        if (!(p.getParameters() instanceof ECPublicKeyParameters))
        {
            throw new IllegalArgumentException("ECPublicKeyParameters are required for encryption.");
        }
        this.key = (ECPublicKeyParameters)p.getParameters();
        this.random = p.getRandom();
    }
    else
    {
        if (!(param instanceof ECPublicKeyParameters))
        {
            throw new IllegalArgumentException("ECPublicKeyParameters are required for encryption.");
        }

        this.key = (ECPublicKeyParameters)param;
        this.random = new SecureRandom();
    }
}
 

import org.bouncycastle.crypto.params.ParametersWithRandom; //导入依赖的package包/类
public void init(boolean forSigning, CipherParameters param)
{
    if (forSigning)
    {
        if (param instanceof ParametersWithRandom)
        {
            ParametersWithRandom rParam = (ParametersWithRandom)param;

            this.random = rParam.getRandom();
            param = rParam.getParameters();
        }
        else
        {
            this.random = new SecureRandom();
        }

        this.key = (ECPrivateKeyParameters)param;
    }
    else
    {
        this.key = (ECPublicKeyParameters)param;
    }

}
 

import org.bouncycastle.crypto.params.ParametersWithRandom; //导入依赖的package包/类
public void init(
    boolean                 forSigning,
    CipherParameters        param)
{
    if (forSigning)
    {
        if (param instanceof ParametersWithRandom)
        {
            ParametersWithRandom    rParam = (ParametersWithRandom)param;

            this.random = rParam.getRandom();
            this.key = (ECPrivateKeyParameters)rParam.getParameters();
        }
        else
        {
            this.random = new SecureRandom();
            this.key = (ECPrivateKeyParameters)param;
        }
    }
    else
    {
        this.key = (ECPublicKeyParameters)param;
    }
}
 

import org.bouncycastle.crypto.params.ParametersWithRandom; //导入依赖的package包/类
public void init(
    boolean          forSigning, 
    CipherParameters param) 
{
    this.forSigning = forSigning;
    
    if (forSigning)
    {
        if (param instanceof ParametersWithRandom)
        {
            ParametersWithRandom    rParam = (ParametersWithRandom)param;

            this.random = rParam.getRandom();
            this.key = (ECPrivateKeyParameters)rParam.getParameters();
        }
        else
        {
            this.random = new SecureRandom();
            this.key = (ECPrivateKeyParameters)param;
        }
    }
    else
    {
        this.key = (ECPublicKeyParameters)param;
    }
}
 

import org.bouncycastle.crypto.params.ParametersWithRandom; //导入依赖的package包/类
public void init(
    boolean                 forSigning,
    CipherParameters        param)
{
    if (forSigning)
    {
        if (param instanceof ParametersWithRandom)
        {
            ParametersWithRandom    rParam = (ParametersWithRandom)param;

            this.random = rParam.getRandom();
            this.key = (DSAPrivateKeyParameters)rParam.getParameters();
        }
        else
        {
            this.random = new SecureRandom();
            this.key = (DSAPrivateKeyParameters)param;
        }
    }
    else
    {
        this.key = (DSAPublicKeyParameters)param;
    }
}
 

import org.bouncycastle.crypto.params.ParametersWithRandom; //导入依赖的package包/类
protected void engineInitSign(
    PrivateKey privateKey)
    throws InvalidKeyException
{
    CipherParameters param = null;

    if (privateKey instanceof ECKey)
    {
        param = ECUtil.generatePrivateKeyParameter(privateKey);
    }

    digest = new GOST3411Digest(DEFAULT_SBOX);

    if (appRandom != null)
    {
        signer.init(true, new ParametersWithRandom(param, appRandom));
    }
    else
    {
        signer.init(true, param);
    }
}
 

import org.bouncycastle.crypto.params.ParametersWithRandom; //导入依赖的package包/类
protected void engineInitSign(
    PrivateKey  privateKey)
    throws InvalidKeyException
{
    CipherParameters    param;

    if (privateKey instanceof ECKey)
    {
        param = ECUtil.generatePrivateKeyParameter(privateKey);
    }
    else
    {
        param = GOST3410Util.generatePrivateKeyParameter(privateKey);
    }

    digest.reset();

    if (random != null)
    {
        signer.init(true, new ParametersWithRandom(param, random));
    }
    else
    {
        signer.init(true, param);
    }
}