Java 类org.bouncycastle.crypto.CipherParameters 实例源码

项目：lastpass-java 文件：SimpleAesManaged.java

@Override
    public String decrypt(byte[] encrypted) {
//        Cipher cipher = null;
        String plain;
        try {
//            Security.addProvider(new BouncyCastlePQCProvider());
//            cipher = Cipher.getInstance("AES/CBC/PKCS5Padding", new BouncyCastlePQCProvider());
//            cipher.init(Cipher.DECRYPT_MODE, new SecretKeySpec(encryptionKey, "AES"), new IvParameterSpec(iv));
//            plain = new String(cipher.doFinal(encrypted), "UTF-8");
            KeyParameter keyParam = new KeyParameter(encryptionKey);
            CipherParameters params = new ParametersWithIV(keyParam, iv);
            BlockCipherPadding padding = new PKCS7Padding();
            BufferedBlockCipher cipher = new PaddedBufferedBlockCipher(
                    new CBCBlockCipher(new AESEngine()), padding);
            cipher.reset();
            cipher.init(false, params);
            byte[] buffer = new byte[cipher.getOutputSize(encrypted.length)];
            int len = cipher.processBytes(encrypted, 0, encrypted.length, buffer, 0);
            len += cipher.doFinal(buffer, len);
            byte[] out = Arrays.copyOfRange(buffer, 0, len);
            plain = new String(out, "UTF-8");
        } catch (Exception e) {
            throw new RuntimeException("decrypt error in SimpleAesManaged", e);
        }
        return plain;
    }

项目：ipack 文件：SICBlockCipher.java

public void init(
    boolean             forEncryption, //ignored by this CTR mode
    CipherParameters    params)
    throws IllegalArgumentException
{
    if (params instanceof ParametersWithIV)
    {
      ParametersWithIV ivParam = (ParametersWithIV)params;
      byte[]           iv      = ivParam.getIV();
      System.arraycopy(iv, 0, IV, 0, IV.length);

      reset();

      // if null it's an IV changed only.
      if (ivParam.getParameters() != null)
      {
        cipher.init(true, ivParam.getParameters());
      }
    }
    else
    {
        throw new IllegalArgumentException("SIC mode requires ParametersWithIV");
    }
}

项目：ipack 文件：ECDSASigner.java

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;
    }
}

项目：ipack 文件：ECNewPublicKeyTransform.java

/**
 * 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();
    }
}

项目：ipack 文件：SignatureSpi.java

protected void engineInitVerify(
    PublicKey   publicKey)
    throws InvalidKeyException
{
    CipherParameters    param;

    if (publicKey instanceof ECPublicKey)
    {
        param = ECUtil.generatePublicKeyParameter(publicKey);
    }
    else if (publicKey instanceof GOST3410Key)
    {
        param = GOST3410Util.generatePublicKeyParameter(publicKey);
    }
    else
    {
        try
        {
            byte[]  bytes = publicKey.getEncoded();

            publicKey = BouncyCastleProvider.getPublicKey(SubjectPublicKeyInfo.getInstance(bytes));

            if (publicKey instanceof ECPublicKey)
            {
                param = ECUtil.generatePublicKeyParameter(publicKey);
            }
            else
            {
                throw new InvalidKeyException("can't recognise key type in DSA based signer");
            }
        }
        catch (Exception e)
        {
            throw new InvalidKeyException("can't recognise key type in DSA based signer");
        }
    }

    digest.reset();
    signer.init(false, param);
}

项目：ipack 文件：OAEPEncoding.java

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;
}

项目：ipack 文件：SipHash.java

public void init(CipherParameters params)
    throws IllegalArgumentException
{
    if (!(params instanceof KeyParameter))
    {
        throw new IllegalArgumentException("'params' must be an instance of KeyParameter");
    }
    KeyParameter keyParameter = (KeyParameter)params;
    byte[] key = keyParameter.getKey();
    if (key.length != 16)
    {
        throw new IllegalArgumentException("'params' must be a 128-bit key");
    }

    this.k0 = Pack.littleEndianToLong(key, 0);
    this.k1 = Pack.littleEndianToLong(key, 8);

    reset();
}

项目：ipack 文件：PBE.java

/**
 * generate a PBE based key suitable for a MAC algorithm, the
 * key size is chosen according the MAC size, or the hashing algorithm,
 * whichever is greater.
 */
public static CipherParameters makePBEMacParameters(
    PBEKeySpec keySpec,
    int type,
    int hash,
    int keySize)
{
    PBEParametersGenerator  generator = makePBEGenerator(type, hash);
    byte[]                  key;
    CipherParameters        param;

    key = convertPassword(type, keySpec);

    generator.init(key, keySpec.getSalt(), keySpec.getIterationCount());

    param = generator.generateDerivedMacParameters(keySize);

    for (int i = 0; i != key.length; i++)
    {
        key[i] = 0;
    }

    return param;
}

项目：ipack 文件：NTRUEngine.java

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();
    }
}

项目：ipack 文件：PKCS5S1ParametersGenerator.java

/**
 * Generate a key parameter derived from the password, salt, and iteration
 * count we are currently initialised with.
 *
 * @param keySize the size of the key we want (in bits)
 * @return a KeyParameter object.
 * @exception IllegalArgumentException if the key length larger than the base hash size.
 */
public CipherParameters generateDerivedParameters(
    int keySize)
{
    keySize = keySize / 8;

    if (keySize > digest.getDigestSize())
    {
        throw new IllegalArgumentException(
               "Can't generate a derived key " + keySize + " bytes long.");
    }

    byte[]  dKey = generateDerivedKey();

    return new KeyParameter(dKey, 0, keySize);
}

项目：ipack 文件：SignatureSpi.java

protected void engineInitSign(
    PrivateKey privateKey)
    throws InvalidKeyException
{
    CipherParameters param = ECUtil.generatePrivateKeyParameter(privateKey);

    digest.reset();

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

项目：ipack 文件：PKCS12PBEUtils.java

static CipherParameters createCipherParameters(ASN1ObjectIdentifier algorithm, ExtendedDigest digest, int blockSize, PKCS12PBEParams pbeParams, char[] password)
{
    PKCS12ParametersGenerator pGen = new PKCS12ParametersGenerator(digest);

    pGen.init(PKCS12ParametersGenerator.PKCS12PasswordToBytes(password), pbeParams.getIV(), pbeParams.getIterations().intValue());

    CipherParameters params;

    if (PKCS12PBEUtils.hasNoIv(algorithm))
    {
        params = pGen.generateDerivedParameters(PKCS12PBEUtils.getKeySize(algorithm));
    }
    else
    {
        params = pGen.generateDerivedParameters(PKCS12PBEUtils.getKeySize(algorithm), blockSize * 8);

        if (PKCS12PBEUtils.isDesAlg(algorithm))
        {
            DESedeParameters.setOddParity(((KeyParameter)((ParametersWithIV)params).getParameters()).getKey());
        }
    }
    return params;
}

项目：ipack 文件：RC4Engine.java

/**
  * initialise a RC4 cipher.
  *
  * @param forEncryption whether or not we are for encryption.
  * @param params the parameters required to set up the cipher.
  * @exception IllegalArgumentException if the params argument is
  * inappropriate.
  */
 public void init(
     boolean             forEncryption, 
     CipherParameters     params
)
 {
     if (params instanceof KeyParameter)
     {
         /* 
          * RC4 encryption and decryption is completely
          * symmetrical, so the 'forEncryption' is 
          * irrelevant.
          */
         workingKey = ((KeyParameter)params).getKey();
         setKey(workingKey);

         return;
     }

     throw new IllegalArgumentException("invalid parameter passed to RC4 init - " + params.getClass().getName());
 }

项目：ipack 文件：XTEAEngine.java

/**
 * initialise
 *
 * @param forEncryption whether or not we are for encryption.
 * @param params the parameters required to set up the cipher.
 * @exception IllegalArgumentException if the params argument is
 * inappropriate.
 */
public void init(
    boolean             forEncryption,
    CipherParameters    params)
{
    if (!(params instanceof KeyParameter))
    {
        throw new IllegalArgumentException("invalid parameter passed to TEA init - " + params.getClass().getName());
    }

    _forEncryption = forEncryption;
    _initialised = true;

    KeyParameter       p = (KeyParameter)params;

    setKey(p.getKey());
}

项目：ipack 文件：GMac.java

/**
 * Initialises the GMAC - requires a {@link ParametersWithIV} providing a {@link KeyParameter}
 * and a nonce.
 */
public void init(final CipherParameters params) throws IllegalArgumentException
{
    if (params instanceof ParametersWithIV)
    {
        final ParametersWithIV param = (ParametersWithIV)params;

        final byte[] iv = param.getIV();
        final KeyParameter keyParam = (KeyParameter)param.getParameters();

        // GCM is always operated in encrypt mode to calculate MAC
        cipher.init(true, new AEADParameters(keyParam, macSizeBits, iv));
    }
    else
    {
        throw new IllegalArgumentException("GMAC requires ParametersWithIV");
    }
}

项目：ipack 文件：BlowfishEngine.java

/**
 * initialise a Blowfish cipher.
 *
 * @param encrypting whether or not we are for encryption.
 * @param params the parameters required to set up the cipher.
 * @exception IllegalArgumentException if the params argument is
 * inappropriate.
 */
public void init(
    boolean             encrypting,
    CipherParameters    params)
{
    if (params instanceof KeyParameter)
    {
        this.encrypting = encrypting;
        this.workingKey = ((KeyParameter)params).getKey();
        setKey(this.workingKey);

        return;
    }

    throw new IllegalArgumentException("invalid parameter passed to Blowfish init - " + params.getClass().getName());
}

项目：ipack 文件：PaddedBufferedBlockCipher.java

/**
 * 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);
    }
}

项目：ipack 文件：BCPBEKey.java

/**
 * @param param
 */
public BCPBEKey(
    String algorithm,
    ASN1ObjectIdentifier oid,
    int type,
    int digest,
    int keySize,
    int ivSize,
    PBEKeySpec pbeKeySpec,
    CipherParameters param)
{
    this.algorithm = algorithm;
    this.oid = oid;
    this.type = type;
    this.digest = digest;
    this.keySize = keySize;
    this.ivSize = ivSize;
    this.pbeKeySpec = pbeKeySpec;
    this.param = param;
}

项目：ipack 文件：NoekeonEngine.java

/**
 * initialise
 *
 * @param forEncryption whether or not we are for encryption.
 * @param params the parameters required to set up the cipher.
 * @exception IllegalArgumentException if the params argument is
 * inappropriate.
 */
public void init(
                 boolean             forEncryption,
                 CipherParameters    params)
{
    if (!(params instanceof KeyParameter))
    {
        throw new IllegalArgumentException("invalid parameter passed to Noekeon init - " + params.getClass().getName());
    }

    _forEncryption = forEncryption;
    _initialised = true;

    KeyParameter       p = (KeyParameter)params;

    setKey(p.getKey());
}

项目：ipack 文件：DSTU4145Signer.java

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;
    }

}

项目：ipack 文件：RFC3394WrapEngine.java

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");
        }
    }
}

项目：mDL-ILP 文件：AESUtils.java

/**
 * AES [FIPS 197] SHALL be used in CMAC-mode [SP 800-38B] with a MAC length of 8 bytes.
 *
 * @param data the data to MAC
 * @param key the key to use
 * @return the 8 byte MAC of the data
 */
public static byte[] performCBC8(byte[] data, byte[] key) {

    // mac size in bits (64 bits = 8 bytes)
    final Mac cbc8 = new CMac(new AESEngine(), 64);
    CipherParameters params = new KeyParameter(key);
    cbc8.init(params);

    byte[] result = new byte[8];
    cbc8.update(data, 0, data.length);
    cbc8.doFinal(result, 0);

    return result;
}

项目：ipack 文件：PBESecretKeyFactory.java

protected SecretKey engineGenerateSecret(
    KeySpec keySpec)
    throws InvalidKeySpecException
{
    if (keySpec instanceof PBEKeySpec)
    {
        PBEKeySpec pbeSpec = (PBEKeySpec)keySpec;
        CipherParameters param;

        if (pbeSpec.getSalt() == null)
        {
            return new BCPBEKey(this.algName, this.algOid, scheme, digest, keySize, ivSize, pbeSpec, null);
        }

        if (forCipher)
        {
            param = PBE.Util.makePBEParameters(pbeSpec, scheme, digest, keySize, ivSize);
        }
        else
        {
            param = PBE.Util.makePBEMacParameters(pbeSpec, scheme, digest, keySize);
        }

        return new BCPBEKey(this.algName, this.algOid, scheme, digest, keySize, ivSize, pbeSpec, param);
    }

    throw new InvalidKeySpecException("Invalid KeySpec");
}

项目：mDL-ILP 文件：AESUtils.java

/**
 * AES [FIPS 197] SHALL be used in CMAC-mode [SP 800-38B] with a MAC length of 8 bytes.
 *
 * @param data the data to MAC
 * @param key the key to use
 * @return the 8 byte MAC of the data
 */
public static byte[] performCBC8(byte[] data, byte[] key) {

    // mac size in bits (64 bits = 8 bytes)
    final Mac cbc8 = new CMac(new AESEngine(), 64);
    CipherParameters params = new KeyParameter(key);
    cbc8.init(params);

    byte[] result = new byte[8];
    cbc8.update(data, 0, data.length);
    cbc8.doFinal(result, 0);

    return result;
}

项目：ipack 文件：RSAKeyEncapsulation.java

/**
 * Initialise the RSA-KEM.
 *
 * @param key the recipient's public (for encryption) or private (for decryption) key.
 */
public void init(CipherParameters key)
    throws IllegalArgumentException
{
    if (!(key instanceof RSAKeyParameters))
    {
        throw new IllegalArgumentException("RSA key required");
    }
    else
    {
        this.key = (RSAKeyParameters)key;
    }
}

项目：ipack 文件：PKCS12ParametersGenerator.java

/**
 * Generate a key with initialisation vector parameter derived from
 * the password, salt, and iteration count we are currently initialised
 * with.
 *
 * @param keySize the size of the key we want (in bits)
 * @param ivSize the size of the iv we want (in bits)
 * @return a ParametersWithIV object.
 */
public CipherParameters generateDerivedParameters(
    int     keySize,
    int     ivSize)
{
    keySize = keySize / 8;
    ivSize = ivSize / 8;

    byte[]  dKey = generateDerivedKey(KEY_MATERIAL, keySize);

    byte[]  iv = generateDerivedKey(IV_MATERIAL, ivSize);

    return new ParametersWithIV(new KeyParameter(dKey, 0, keySize), iv, 0, ivSize);
}

项目：keepass2android 文件：PBE.java

/**
 * construct a key and iv (if necessary) suitable for use with a 
 * Cipher.
 */
static CipherParameters makePBEParameters(
    PBEKeySpec              keySpec,
    int                     type,
    int                     hash,
    int                     keySize,
    int                     ivSize)
{    
    PBEParametersGenerator  generator = makePBEGenerator(type, hash);
    byte[]                  key;
    CipherParameters        param;

    if (type == PKCS12)
    {
        key = PBEParametersGenerator.PKCS12PasswordToBytes(keySpec.getPassword());
    }
    else
    {   
        key = PBEParametersGenerator.PKCS5PasswordToBytes(keySpec.getPassword());
    }

    generator.init(key, keySpec.getSalt(), keySpec.getIterationCount());

    if (ivSize != 0)
    {
        param = generator.generateDerivedParameters(keySize, ivSize);
    }
    else
    {
        param = generator.generateDerivedParameters(keySize);
    }

    for (int i = 0; i != key.length; i++)
    {
        key[i] = 0;
    }

    return param;
}

项目：keepass2android 文件：PBE.java

/**
 * generate a PBE based key suitable for a MAC algorithm, the
 * key size is chosen according the MAC size, or the hashing algorithm,
 * whichever is greater.
 */
static CipherParameters makePBEMacParameters(
    PBEKeySpec              keySpec,
    int                     type,
    int                     hash,
    int                     keySize)
{
    PBEParametersGenerator  generator = makePBEGenerator(type, hash);
    byte[]                  key;
    CipherParameters        param;

    if (type == PKCS12)
    {
        key = PBEParametersGenerator.PKCS12PasswordToBytes(keySpec.getPassword());
    }
    else
    {   
        key = PBEParametersGenerator.PKCS5PasswordToBytes(keySpec.getPassword());
    }

    generator.init(key, keySpec.getSalt(), keySpec.getIterationCount());

    param = generator.generateDerivedMacParameters(keySize);

    for (int i = 0; i != key.length; i++)
    {
        key[i] = 0;
    }

    return param;
}

项目：ipack 文件：PKCS5S2ParametersGenerator.java

/**
 * Generate a key parameter derived from the password, salt, and iteration
 * count we are currently initialised with.
 *
 * @param keySize the size of the key we want (in bits)
 * @return a KeyParameter object.
 */
public CipherParameters generateDerivedParameters(
    int keySize)
{
    keySize = keySize / 8;

    byte[]  dKey = generateDerivedKey(keySize);

    return new KeyParameter(dKey, 0, keySize);
}

项目：keepass2android 文件：Salsa20Engine.java

/**
 * initialise a Salsa20 cipher.
 *
 * @param forEncryption whether or not we are for encryption.
 * @param params the parameters required to set up the cipher.
 * @exception IllegalArgumentException if the params argument is
 * inappropriate.
 */
public void init(
    boolean             forEncryption, 
    CipherParameters     params)
{
    /* 
    * Salsa20 encryption and decryption is completely
    * symmetrical, so the 'forEncryption' is 
    * irrelevant. (Like 90% of stream ciphers)
    */

    if (!(params instanceof ParametersWithIV))
    {
        throw new IllegalArgumentException("Salsa20 Init parameters must include an IV");
    }

    ParametersWithIV ivParams = (ParametersWithIV) params;

    byte[] iv = ivParams.getIV();

    if (iv == null || iv.length != 8)
    {
        throw new IllegalArgumentException("Salsa20 requires exactly 8 bytes of IV");
    }

    if (!(ivParams.getParameters() instanceof KeyParameter))
    {
        throw new IllegalArgumentException("Salsa20 Init parameters must include a key");
    }

    KeyParameter key = (KeyParameter) ivParams.getParameters();

    workingKey = key.getKey();
    workingIV = iv;

    setKey(workingKey, workingIV);
}

项目：truevfs 文件：CtrBlockCipher.java

@Override
public void init(
        final boolean forEncryption, // not used for CTR mode
        final CipherParameters params) {
    final ParametersWithIV ivParams = (ParametersWithIV) params;
    final byte[] iv = ivParams.getIV();
    System.arraycopy(iv, 0, IV, 0, IV.length);
    reset();
    cipher.init(true, ivParams.getParameters());
}

项目：keepass2android 文件：HMac.java

public void init(
    CipherParameters params)
{
    digest.reset();

    byte[] key = ((KeyParameter)params).getKey();

    if (key.length > blockLength)
    {
        digest.update(key, 0, key.length);
        digest.doFinal(inputPad, 0);
        for (int i = digestSize; i < inputPad.length; i++)
        {
            inputPad[i] = 0;
        }
    }
    else
    {
        System.arraycopy(key, 0, inputPad, 0, key.length);
        for (int i = key.length; i < inputPad.length; i++)
        {
            inputPad[i] = 0;
        }
    }

    outputPad = new byte[inputPad.length];
    System.arraycopy(inputPad, 0, outputPad, 0, inputPad.length);

    for (int i = 0; i < inputPad.length; i++)
    {
        inputPad[i] ^= IPAD;
    }

    for (int i = 0; i < outputPad.length; i++)
    {
        outputPad[i] ^= OPAD;
    }

    digest.update(inputPad, 0, inputPad.length);
}

项目：keepass2android 文件：CBCBlockCipher.java

/**
 * Initialise the cipher and, possibly, the initialisation vector (IV).
 * If an IV isn't passed as part of the parameter, the IV will be all zeros.
 *
 * @param encrypting 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             encrypting,
    CipherParameters    params)
    throws IllegalArgumentException
{
    this.encrypting = encrypting;

    if (params instanceof ParametersWithIV)
    {
            ParametersWithIV ivParam = (ParametersWithIV)params;
            byte[]      iv = ivParam.getIV();

            if (iv.length != blockSize)
            {
                throw new IllegalArgumentException("initialisation vector must be the same length as block size");
            }

            System.arraycopy(iv, 0, IV, 0, iv.length);

            reset();

            cipher.init(encrypting, ivParam.getParameters());
    }
    else
    {
            reset();

            cipher.init(encrypting, params);
    }
}

项目：ipack 文件：PKCS12ParametersGenerator.java

/**
 * Generate a key parameter derived from the password, salt, and iteration
 * count we are currently initialised with.
 *
 * @param keySize the size of the key we want (in bits)
 * @return a KeyParameter object.
 */
public CipherParameters generateDerivedParameters(
    int keySize)
{
    keySize = keySize / 8;

    byte[]  dKey = generateDerivedKey(KEY_MATERIAL, keySize);

    return new KeyParameter(dKey, 0, keySize);
}

项目：ipack 文件：BcKEKRecipient.java

protected CipherParameters extractSecretKey(AlgorithmIdentifier keyEncryptionAlgorithm, AlgorithmIdentifier contentEncryptionAlgorithm, byte[] encryptedContentEncryptionKey)
    throws CMSException
{
    try
    {
        return CMSUtils.getBcKey(unwrapper.generateUnwrappedKey(contentEncryptionAlgorithm, encryptedContentEncryptionKey));
    }
    catch (OperatorException e)
    {
        throw new CMSException("exception unwrapping key: " + e.getMessage(), e);
    }
}

项目：ipack 文件：VMPCMac.java

public void init(CipherParameters params) throws IllegalArgumentException
{
    if (!(params instanceof ParametersWithIV))
    {
        throw new IllegalArgumentException(
            "VMPC-MAC Init parameters must include an IV");
    }

    ParametersWithIV ivParams = (ParametersWithIV) params;
    KeyParameter key = (KeyParameter) ivParams.getParameters();

    if (!(ivParams.getParameters() instanceof KeyParameter))
    {
        throw new IllegalArgumentException(
            "VMPC-MAC Init parameters must include a key");
    }

    this.workingIV = ivParams.getIV();

    if (workingIV == null || workingIV.length < 1 || workingIV.length > 768)
    {
        throw new IllegalArgumentException(
            "VMPC-MAC requires 1 to 768 bytes of IV");
    }

    this.workingKey = key.getKey();

    reset();

}

项目：keepass2android 文件：PKCS12ParametersGenerator.java

/**
 * Generate a key with initialisation vector parameter derived from
 * the password, salt, and iteration count we are currently initialised
 * with.
 *
 * @param keySize the size of the key we want (in bits)
 * @param ivSize the size of the iv we want (in bits)
 * @return a ParametersWithIV object.
 */
public CipherParameters generateDerivedParameters(
    int     keySize,
    int     ivSize)
{
    keySize = keySize / 8;
    ivSize = ivSize / 8;

    byte[]  dKey = generateDerivedKey(KEY_MATERIAL, keySize);

    byte[]  iv = generateDerivedKey(IV_MATERIAL, ivSize);

    return new ParametersWithIV(new KeyParameter(dKey, 0, keySize), iv, 0, ivSize);
}

项目：ipack 文件：DSASigner.java

protected void engineInitVerify(
    PublicKey   publicKey)
    throws InvalidKeyException
{
    CipherParameters    param;

    if (publicKey instanceof DSAKey)
    {
        param = DSAUtil.generatePublicKeyParameter(publicKey);
    }
    else
    {
        try
        {
            byte[]  bytes = publicKey.getEncoded();

            publicKey = new BCDSAPublicKey(SubjectPublicKeyInfo.getInstance(bytes));

            if (publicKey instanceof DSAKey)
            {
                param = DSAUtil.generatePublicKeyParameter(publicKey);
            }
            else
            {
                throw new InvalidKeyException("can't recognise key type in DSA based signer");
            }
        }
        catch (Exception e)
        {
            throw new InvalidKeyException("can't recognise key type in DSA based signer");
        }
    }

    digest.reset();
    signer.init(false, param);
}

项目：ipack 文件：RSAKeyEncapsulation.java

/**
 * Generate and encapsulate a random session key.
 *
 * @param out    the output buffer for the encapsulated key.
 * @param outOff the offset for the output buffer.
 * @param keyLen the length of the random session key.
 * @return the random session key.
 */
public CipherParameters encrypt(byte[] out, int outOff, int keyLen)
    throws IllegalArgumentException
{
    if (key.isPrivate())
    {
        throw new IllegalArgumentException("Public key required for encryption");
    }

    BigInteger n = key.getModulus();
    BigInteger e = key.getExponent();

    // Generate the ephemeral random and encode it    
    BigInteger r = BigIntegers.createRandomInRange(ZERO, n.subtract(ONE), rnd);
    byte[] R = BigIntegers.asUnsignedByteArray((n.bitLength() + 7) / 8, r);

    // Encrypt the random and encode it     
    BigInteger c = r.modPow(e, n);
    byte[] C = BigIntegers.asUnsignedByteArray((n.bitLength() + 7) / 8, c);
    System.arraycopy(C, 0, out, outOff, C.length);


    // Initialise the KDF
    kdf.init(new KDFParameters(R, null));

    // Generate the secret key
    byte[] K = new byte[keyLen];
    kdf.generateBytes(K, 0, K.length);

    return new KeyParameter(K);
}

项目：keepass2android 文件：PKCS5S2ParametersGenerator.java

/**
 * Generate a key with initialisation vector parameter derived from
 * the password, salt, and iteration count we are currently initialised
 * with.
 *
 * @param keySize the size of the key we want (in bits)
 * @param ivSize the size of the iv we want (in bits)
 * @return a ParametersWithIV object.
 */
public CipherParameters generateDerivedParameters(
    int     keySize,
    int     ivSize)
{
    keySize = keySize / 8;
    ivSize = ivSize / 8;

    byte[]  dKey = generateDerivedKey(keySize + ivSize);

    return new ParametersWithIV(new KeyParameter(dKey, 0, keySize), dKey, keySize, ivSize);
}