Example #1
0
  public static void main(String[] args) {
    try {

      AlgorithmParameterGenerator paramGen = AlgorithmParameterGenerator.getInstance("DSA");
      paramGen.init(1024);

      AlgorithmParameters params = paramGen.generateParameters();

      DSAParameterSpec dsaParameterSpec = params.getParameterSpec(DSAParameterSpec.class);

      KeyPairGenerator keyPairGenerator = KeyPairGenerator.getInstance("DSA");
      keyPairGenerator.initialize(dsaParameterSpec);

      KeyPair keyPair = keyPairGenerator.generateKeyPair();

      PublicKey publicKey = keyPair.getPublic();
      PrivateKey privateKey = keyPair.getPrivate();

      saveKey("BpubKey", publicKey);
      saveKey("BprivKey", privateKey);

    } catch (NoSuchAlgorithmException
        | InvalidParameterSpecException
        | InvalidAlgorithmParameterException e) {
      e.printStackTrace();
    }
  }
  public static void main(String[] args) throws Exception {

    byte[] iv_1 = {
      (byte) 0x11, (byte) 0x11, (byte) 0x11, (byte) 0x11,
      (byte) 0x11, (byte) 0x11, (byte) 0x11, (byte) 0x11,
      (byte) 0x33, (byte) 0x33
    };

    // check that RC2 is supported by our provider
    AlgorithmParameters rc2Params = AlgorithmParameters.getInstance("RC2", "SunJCE");

    // check that getAlgorithm returns "RC2"
    if (!rc2Params.getAlgorithm().equals("RC2")) {
      throw new Exception(
          "getAlgorithm() returned " + rc2Params.getAlgorithm() + " instead of RC2");
    }

    // test parameters with effective key size and iv
    byte[] encoded = testParams(rc2Params, new RC2ParameterSpec(2, iv_1));

    // test parameters with just iv
    encoded = testParams(AlgorithmParameters.getInstance("RC2"), new RC2ParameterSpec(0, iv_1));

    // test vectors in RFC 2268
    runTests(tests);
  }
Example #3
0
  public static Message encrypt(PublicKey pubKey, byte[] input) throws CryptoException {
    Message message = new Message();
    message.pubKey = pubKey.getEncoded();

    KeyGenerator keyGen;
    try {
      keyGen = KeyGenerator.getInstance("AES");
    } catch (NoSuchAlgorithmException e) {
      throw new CryptoException(e);
    }
    keyGen.init(128);
    SecretKey secretKey = keyGen.generateKey();

    try {
      Cipher rsaCipher = Cipher.getInstance("RSA/ECB/PKCS1Padding");
      rsaCipher.init(Cipher.ENCRYPT_MODE, pubKey);
      message.sessionKey = rsaCipher.doFinal(secretKey.getEncoded());

      Cipher aesCipher = Cipher.getInstance("AES/CBC/PKCS5Padding");
      aesCipher.init(Cipher.ENCRYPT_MODE, secretKey);
      AlgorithmParameters params = aesCipher.getParameters();
      message.iv = params.getParameterSpec(IvParameterSpec.class).getIV();
      message.ciphertext = aesCipher.doFinal(input);
    } catch (NoSuchAlgorithmException
        | NoSuchPaddingException
        | InvalidKeyException
        | IllegalBlockSizeException
        | BadPaddingException
        | InvalidParameterSpecException e) {
      throw new CryptoException(e);
    }

    return message;
  }
  private DERObject createDERForRecipient(byte[] in, X509Certificate cert)
      throws IOException, GeneralSecurityException {

    String s = "1.2.840.113549.3.2";

    AlgorithmParameterGenerator algorithmparametergenerator =
        AlgorithmParameterGenerator.getInstance(s);
    AlgorithmParameters algorithmparameters = algorithmparametergenerator.generateParameters();
    ByteArrayInputStream bytearrayinputstream =
        new ByteArrayInputStream(algorithmparameters.getEncoded("ASN.1"));
    ASN1InputStream asn1inputstream = new ASN1InputStream(bytearrayinputstream);
    DERObject derobject = asn1inputstream.readObject();
    KeyGenerator keygenerator = KeyGenerator.getInstance(s);
    keygenerator.init(128);
    SecretKey secretkey = keygenerator.generateKey();
    Cipher cipher = Cipher.getInstance(s);
    cipher.init(1, secretkey, algorithmparameters);
    byte[] abyte1 = cipher.doFinal(in);
    DEROctetString deroctetstring = new DEROctetString(abyte1);
    KeyTransRecipientInfo keytransrecipientinfo =
        computeRecipientInfo(cert, secretkey.getEncoded());
    DERSet derset = new DERSet(new RecipientInfo(keytransrecipientinfo));
    AlgorithmIdentifier algorithmidentifier =
        new AlgorithmIdentifier(new DERObjectIdentifier(s), derobject);
    EncryptedContentInfo encryptedcontentinfo =
        new EncryptedContentInfo(PKCSObjectIdentifiers.data, algorithmidentifier, deroctetstring);
    EnvelopedData env = new EnvelopedData(null, derset, encryptedcontentinfo, null);
    ContentInfo contentinfo = new ContentInfo(PKCSObjectIdentifiers.envelopedData, env);
    return contentinfo.getDERObject();
  }
 AlgorithmParameters implGetParameters() {
   AlgorithmParameters params = null;
   if (salt == null) {
     // Cipher is not initialized with parameters;
     // follow the recommendation in PKCS12 v1.0
     // section B.4 to generate salt and iCount.
     salt = new byte[DEFAULT_SALT_LENGTH];
     SunJCE.getRandom().nextBytes(salt);
     iCount = DEFAULT_COUNT;
   }
   PBEParameterSpec pbeSpec = new PBEParameterSpec(salt, iCount);
   try {
     params = AlgorithmParameters.getInstance(pbeAlgo, "SunJCE");
   } catch (GeneralSecurityException gse) {
     // should never happen
     throw new RuntimeException("SunJCE provider is not configured properly");
   }
   try {
     params.init(pbeSpec);
   } catch (InvalidParameterSpecException ipse) {
     // should never happen
     throw new RuntimeException("PBEParameterSpec not supported");
   }
   return params;
 }
Example #6
0
 /**
  * Generate a spec from a curve name
  *
  * @return null if fail
  */
 private static ECParameterSpec genSpec(String name) {
   // convert the ECGenParameterSpecs to ECParameterSpecs for several reasons:
   // 1) to check availability
   // 2) efficiency
   // 3) SigUtil must cast the AlgorithmParameterSpec to a ECParameterSpec
   //    to convert a I2P key to a Java key. Sadly, a ECGenParameterSpec
   //    is not a ECParameterSpec.
   try {
     AlgorithmParameters ap;
     try {
       ap = AlgorithmParameters.getInstance("EC");
     } catch (Exception e) {
       if (BC_AVAILABLE) {
         log("Named curve " + name + " is not available, trying BC", e);
         ap = AlgorithmParameters.getInstance("EC", "BC");
         log("Fallback to BC worked for named curve " + name);
       } else {
         throw e;
       }
     }
     ECGenParameterSpec ecgps = new ECGenParameterSpec(name);
     ap.init(ecgps);
     ECParameterSpec rv = ap.getParameterSpec(ECParameterSpec.class);
     log("Named curve " + name + " loaded");
     return rv;
   } catch (Exception e) {
     log("Named curve " + name + " is not available", e);
     return null;
   }
 }
  /** {@inheritDoc} */
  @Override
  public byte[] encrypt(final byte[] bytes) throws EncyptionException {
    try {
      final javax.crypto.Cipher cipher = javax.crypto.Cipher.getInstance("AES/CBC/PKCS5Padding");
      cipher.init(javax.crypto.Cipher.ENCRYPT_MODE, this.secretKey);

      final AlgorithmParameters params = cipher.getParameters();
      final byte[] ivBytes = params.getParameterSpec(IvParameterSpec.class).getIV();
      final byte[] dataBytes = cipher.doFinal(bytes);
      final byte[] secret = ArrayOfBytesType.TYPE.toBytes(ivBytes, dataBytes);
      return secret;
    } catch (final NoSuchAlgorithmException problem) {
      throw new EncyptionException(problem);
    } catch (final NoSuchPaddingException problem) {
      throw new EncyptionException(problem);
    } catch (final InvalidKeyException problem) {
      throw new EncyptionException(problem);
    } catch (final InvalidParameterSpecException problem) {
      throw new EncyptionException(problem);
    } catch (final IllegalBlockSizeException problem) {
      throw new EncyptionException(problem);
    } catch (final BadPaddingException problem) {
      throw new EncyptionException(problem);
    }
  }
  /**
   * @tests javax.crypto.Cipher#getParameters()
   * @tests javax.crypto.Cipher#init(int, java.security.Key, java.security.AlgorithmParameters,
   *     java.security.SecureRandom)
   */
  public void test_getParameters() throws Exception {

    /*
     * If this test is changed, implement the following:
     * test_initILjava_security_KeyLjava_security_AlgorithmParametersLjava_security_SecureRandom()
     */

    SecureRandom sr = new SecureRandom();
    Cipher cipher = null;

    byte[] apEncoding = null;

    byte[] iv = new byte[8];
    sr.nextBytes(iv);

    AlgorithmParameters ap = AlgorithmParameters.getInstance("DESede");
    ap.init(iv, "RAW");
    apEncoding = ap.getEncoded("ASN.1");

    cipher = Cipher.getInstance(algorithm + "/CBC/PKCS5Padding");
    cipher.init(Cipher.ENCRYPT_MODE, cipherKey, ap, sr);

    byte[] cipherParmsEnc = cipher.getParameters().getEncoded("ASN.1");
    assertTrue("Parameters differ", Arrays.equals(apEncoding, cipherParmsEnc));
  }
 protected void engineInit(
     int paramInt,
     Key paramKey,
     AlgorithmParameters paramAlgorithmParameters,
     SecureRandom paramSecureRandom) {
   Object localObject2 = null;
   Object localObject3 = null;
   if (paramAlgorithmParameters != null) {
     int i = 0;
     for (; ; ) {
       Object localObject1 = localObject3;
       if (i == this.aXo.length) {
         break;
       }
       try {
         localObject1 = paramAlgorithmParameters.getParameterSpec(this.aXo[i]);
       } catch (Exception localException) {
         i += 1;
       }
     }
     localObject2 = localException;
     if (localException == null) {
       throw new InvalidAlgorithmParameterException(
           "can't handle parameter " + paramAlgorithmParameters.toString());
     }
   }
   this.aXe = paramAlgorithmParameters;
   engineInit(paramInt, paramKey, localObject2, paramSecureRandom);
 }
Example #10
0
  private void setSignatureParameters(Signature var1, DEREncodable var2)
      throws NoSuchAlgorithmException, SignatureException, InvalidKeyException {
    if (var2 != null) {
      if (!DERNull.INSTANCE.equals(var2)) {
        String var3 = var1.getAlgorithm();
        Provider var4 = var1.getProvider();
        AlgorithmParameters var5 = AlgorithmParameters.getInstance(var3, var4);

        try {
          byte[] var6 = var2.getDERObject().getDEREncoded();
          var5.init(var6);
        } catch (IOException var17) {
          StringBuilder var9 = (new StringBuilder()).append("IOException decoding parameters: ");
          String var10 = var17.getMessage();
          String var11 = var9.append(var10).toString();
          throw new SignatureException(var11);
        }

        if (var1.getAlgorithm().endsWith("MGF1")) {
          try {
            AlgorithmParameterSpec var7 = var5.getParameterSpec(PSSParameterSpec.class);
            var1.setParameter(var7);
          } catch (GeneralSecurityException var16) {
            StringBuilder var13 = (new StringBuilder()).append("Exception extracting parameters: ");
            String var14 = var16.getMessage();
            String var15 = var13.append(var14).toString();
            throw new SignatureException(var15);
          }
        }
      }
    }
  }
 /**
  * Method getAlgParam.
  *
  * @return AlgorithmParameters
  * @param jceName The name of the algorithm parameters which may depend on the provider
  */
 public AlgorithmParameters getAlgParam(String jceName)
     throws NoSuchAlgorithmException, IOException {
   if (this.param == null) {
     return null;
   }
   AlgorithmParameters ap = AlgorithmParameters.getInstance(jceName);
   ap.init(this.param.getValue());
   return ap;
 }
  /**
   * Generates and returns {@link DHParameterSpec}.
   *
   * @return {@link String}
   * @see AlgorithmParameters
   * @see AlgorithmParameterGenerator
   */
  public static DHParameterSpec generateDiffieHellmanValues()
      throws NoSuchAlgorithmException, InvalidParameterSpecException {

    AlgorithmParameterGenerator parameterGenerator = AlgorithmParameterGenerator.getInstance("DH");
    parameterGenerator.init(1024);

    AlgorithmParameters parameters = parameterGenerator.generateParameters();
    return (DHParameterSpec) parameters.getParameterSpec(DHParameterSpec.class);
  }
Example #13
0
  /** Can be used to generate new parameters */
  public static void main(String[] args) throws Exception {
    AlgorithmParameterGenerator paramGen = AlgorithmParameterGenerator.getInstance(ALGORITHM);
    paramGen.init(1024);

    AlgorithmParameters params = paramGen.generateParameters();

    DHParameterSpec dhSpec = params.getParameterSpec(DHParameterSpec.class);
    System.out.println("l=" + dhSpec.getL());
    System.out.println("g=" + dhSpec.getG());
    System.out.println("p=" + dhSpec.getP());
  }
Example #14
0
 /** Parse the key. Called by X509Key. */
 protected void parseKeyBits() throws InvalidKeyException {
   try {
     AlgorithmParameters algParams = this.algid.getParameters();
     params = algParams.getParameterSpec(ECParameterSpec.class);
     w = ECParameters.decodePoint(key, params.getCurve());
   } catch (IOException e) {
     throw new InvalidKeyException("Invalid EC key", e);
   } catch (InvalidParameterSpecException e) {
     throw new InvalidKeyException("Invalid EC key", e);
   }
 }
Example #15
0
 public AlgorithmParameters getAlgParameters() {
   if (params == null && encodedParams != null) {
     try {
       params = AlgorithmParameters.getInstance(getAlgName());
       params.init(encodedParams);
     } catch (NoSuchAlgorithmException ignore) {
       // FIXME throw exception?
     } catch (IOException ignore) {
     }
   }
   return params;
 }
Example #16
0
  private void testGCMGeneric(byte[] K, byte[] N, byte[] A, byte[] P, byte[] C)
      throws InvalidKeyException, NoSuchAlgorithmException, NoSuchPaddingException,
          IllegalBlockSizeException, BadPaddingException, InvalidAlgorithmParameterException,
          NoSuchProviderException, IOException, InvalidParameterSpecException {
    Cipher eax = Cipher.getInstance("AES/GCM/NoPadding", "BC");
    SecretKeySpec key = new SecretKeySpec(K, "AES");

    // GCMParameterSpec mapped to AEADParameters and overrides default MAC
    // size
    GCMParameterSpec spec = new GCMParameterSpec(128, N);
    eax.init(Cipher.ENCRYPT_MODE, key, spec);

    eax.updateAAD(A);
    byte[] c = eax.doFinal(P);

    if (!areEqual(C, c)) {
      fail("JCE encrypt with additional data and GCMParameterSpec failed.");
    }

    eax = Cipher.getInstance("GCM", "BC");
    eax.init(Cipher.DECRYPT_MODE, key, spec);
    eax.updateAAD(A);
    byte[] p = eax.doFinal(C);

    if (!areEqual(P, p)) {
      fail("JCE decrypt with additional data and GCMParameterSpec failed.");
    }

    AlgorithmParameters algParams = eax.getParameters();

    byte[] encParams = algParams.getEncoded();

    GCMParameters gcmParameters = GCMParameters.getInstance(encParams);

    if (!Arrays.areEqual(spec.getIV(), gcmParameters.getNonce())
        || spec.getTLen() != gcmParameters.getIcvLen()) {
      fail("parameters mismatch");
    }

    GCMParameterSpec gcmSpec = algParams.getParameterSpec(GCMParameterSpec.class);

    if (!Arrays.areEqual(gcmSpec.getIV(), gcmParameters.getNonce())
        || gcmSpec.getTLen() != gcmParameters.getIcvLen() * 8) {
      fail("spec parameters mismatch");
    }

    if (!Arrays.areEqual(eax.getIV(), gcmParameters.getNonce())) {
      fail("iv mismatch");
    }
  }
Example #17
0
    private AlgorithmParameters checkParameters(Cipher c, byte[] salt, int iCount)
        throws InvalidParameterSpecException {
      AlgorithmParameters param = c.getParameters();
      PBEParameterSpec spec = (PBEParameterSpec) param.getParameterSpec(PBEParameterSpec.class);

      if (!Arrays.areEqual(salt, spec.getSalt())) {
        fail("" + algorithm + "failed salt test");
      }

      if (iCount != spec.getIterationCount()) {
        fail("" + algorithm + "failed count test");
      }
      return param;
    }
  protected AlgorithmParameters engineGetParameters() {
    if (engineParams == null) {
      if (paramSpec != null) {
        try {
          engineParams = AlgorithmParameters.getInstance("OAEP", "DFBC");
          engineParams.init(paramSpec);
        } catch (Exception e) {
          throw new RuntimeException(e.toString());
        }
      }
    }

    return engineParams;
  }
  public void testAES256CCM() throws Exception {
    byte[] data = "Eric H. Echidna".getBytes();
    ASN1ObjectIdentifier macAlg = CMSAlgorithm.AES256_CCM;
    AlgorithmParameters algParams = AlgorithmParameters.getInstance("CCM", BC);

    algParams.init(new CCMParameters(Hex.decode("000102030405060708090a0b"), 16).getEncoded());

    CMSAuthenticatedDataGenerator adGen = new CMSAuthenticatedDataGenerator();

    X509CertificateHolder origCert = new X509CertificateHolder(_origCert.getEncoded());

    adGen.setOriginatorInfo(new OriginatorInfoGenerator(origCert).generate());

    adGen.addRecipientInfoGenerator(
        new JceKeyTransRecipientInfoGenerator(_reciCert).setProvider(BC));

    CMSAuthenticatedData ad =
        adGen.generate(
            new CMSProcessableByteArray(data),
            new JceCMSMacCalculatorBuilder(macAlg)
                .setAlgorithmParameters(algParams)
                .setProvider(BC)
                .build());

    assertTrue(ad.getOriginatorInfo().getCertificates().getMatches(null).contains(origCert));

    RecipientInformationStore recipients = ad.getRecipientInfos();

    assertEquals(ad.getMacAlgOID(), macAlg.getId());

    Collection c = recipients.getRecipients();

    assertEquals(1, c.size());

    Iterator it = c.iterator();

    while (it.hasNext()) {
      RecipientInformation recipient = (RecipientInformation) it.next();

      assertEquals(recipient.getKeyEncryptionAlgOID(), PKCSObjectIdentifiers.rsaEncryption.getId());

      byte[] recData =
          recipient.getContent(
              new JceKeyTransAuthenticatedRecipient(_reciKP.getPrivate()).setProvider(BC));

      assertTrue(Arrays.equals(data, recData));
      assertEquals(16, ad.getMac().length);
      assertTrue(Arrays.equals(ad.getMac(), recipient.getMac()));
    }
  }
Example #20
0
  /*
   * Generate PBE Algorithm Parameters
   */
  private AlgorithmParameters getAlgorithmParameters(String algorithm) throws IOException {
    AlgorithmParameters algParams = null;

    // create PBE parameters from salt and iteration count
    PBEParameterSpec paramSpec = new PBEParameterSpec(getSalt(), iterationCount);
    try {
      algParams = AlgorithmParameters.getInstance(algorithm);
      algParams.init(paramSpec);
    } catch (Exception e) {
      IOException ioe = new IOException("getAlgorithmParameters failed: " + e.getMessage());
      ioe.initCause(e);
      throw ioe;
    }
    return algParams;
  }
Example #21
0
  protected AlgorithmParameters engineGetParameters() {
    if (engineParam == null) {
      if (engineParams != null) {
        String name = "IES";

        try {
          engineParam = AlgorithmParameters.getInstance(name, BouncyCastleProvider.PROVIDER_NAME);
          engineParam.init(engineParams);
        } catch (Exception e) {
          throw new RuntimeException(e.toString());
        }
      }
    }

    return engineParam;
  }
Example #22
0
 // see JCE spec
 protected AlgorithmParameters engineGetParameters() {
   if (iv == null) {
     return null;
   }
   IvParameterSpec ivSpec = new IvParameterSpec(iv);
   try {
     AlgorithmParameters params =
         AlgorithmParameters.getInstance(keyAlgorithm, P11Util.getSunJceProvider());
     params.init(ivSpec);
     return params;
   } catch (GeneralSecurityException e) {
     // NoSuchAlgorithmException, NoSuchProviderException
     // InvalidParameterSpecException
     throw new ProviderException("Could not encode parameters", e);
   }
 }
  private AlgorithmParameters getParameters() throws NoSuchAlgorithmException {
    AlgorithmParameters ap = AlgorithmParameters.getInstance(this.getAlgName());
    ByteArrayOutputStream bOut = new ByteArrayOutputStream();
    DEROutputStream dOut = new DEROutputStream(bOut);

    try {
      dOut.writeObject(infoObj.getEncryptionAlgorithm().getParameters());
      dOut.close();

      ap.init(bOut.toByteArray());
    } catch (IOException e) {
      throw new NoSuchAlgorithmException("unable to parse parameters");
    }

    return ap;
  }
  private void tryKekAlgorithm(SecretKey kek, ASN1ObjectIdentifier algOid, byte[] encodedParameters)
      throws NoSuchAlgorithmException, NoSuchProviderException, CMSException,
          OperatorCreationException, IOException {
    byte[] data = "Eric H. Echidna".getBytes();

    CMSAuthenticatedDataGenerator adGen = new CMSAuthenticatedDataGenerator();

    byte[] kekId = new byte[] {1, 2, 3, 4, 5};

    adGen.addRecipientInfoGenerator(new JceKEKRecipientInfoGenerator(kekId, kek).setProvider(BC));

    AlgorithmParameters algParams =
        AlgorithmParameters.getInstance(CMSAlgorithm.DES_EDE3_CBC.getId(), "BC");

    algParams.init(encodedParameters);

    CMSAuthenticatedData ad =
        adGen.generate(
            new CMSProcessableByteArray(data),
            new JceCMSMacCalculatorBuilder(CMSAlgorithm.DES_EDE3_CBC)
                .setAlgorithmParameters(algParams)
                .setProvider(BC)
                .build());

    RecipientInformationStore recipients = ad.getRecipientInfos();

    Collection c = recipients.getRecipients();
    Iterator it = c.iterator();

    assertEquals(ad.getMacAlgOID(), CMSAuthenticatedDataGenerator.DES_EDE3_CBC);
    assertEquals(
        ad.getMacAlgorithm().getParameters(), ASN1Primitive.fromByteArray(encodedParameters));

    if (it.hasNext()) {
      RecipientInformation recipient = (RecipientInformation) it.next();

      assertEquals(recipient.getKeyEncryptionAlgOID(), algOid.getId());

      byte[] recData = recipient.getContent(new JceKEKAuthenticatedRecipient(kek).setProvider(BC));

      assertTrue(Arrays.equals(data, recData));
      assertTrue(Arrays.equals(ad.getMac(), recipient.getMac()));
    } else {
      fail("no recipient found");
    }
  }
Example #25
0
  protected AlgorithmParameters engineGetParameters() {
    if (engineParams == null) {
      if (pbeSpec != null) {
        try {
          AlgorithmParameters engineParams =
              AlgorithmParameters.getInstance(pbeAlgorithm, BouncyCastleProvider.PROVIDER_NAME);
          engineParams.init(pbeSpec);

          return engineParams;
        } catch (Exception e) {
          return null;
        }
      }
    }

    return engineParams;
  }
Example #26
0
 /**
  * Create a new <code>EncryptedPrivateKeyInfo</code> object from raw encrypted data and the
  * parameters used for encryption.
  *
  * <p>The <code>encryptedData</code> array is cloned.
  *
  * @param params The encryption algorithm parameters.
  * @param encryptedData The encrypted key data.
  * @throws java.lang.IllegalArgumentException If the <code>encryptedData</code> array is empty
  *     (zero-length).
  * @throws java.security.NoSuchAlgorithmException If the algorithm specified in the parameters is
  *     not supported.
  * @throws java.lang.NullPointerException If <code>encryptedData</code> is null.
  */
 public EncryptedPrivateKeyInfo(AlgorithmParameters params, byte[] encryptedData)
     throws IllegalArgumentException, NoSuchAlgorithmException {
   if (encryptedData.length == 0) {
     throw new IllegalArgumentException("0-length encryptedData");
   }
   this.params = params;
   algName = params.getAlgorithm();
   algOid = getOid(algName);
   this.encryptedData = (byte[]) encryptedData.clone();
 }
  @Override
  protected void engineInit(int opmode, Key key, AlgorithmParameters params, SecureRandom random)
      throws InvalidKeyException, InvalidAlgorithmParameterException {
    if (params != null) {
      throw new InvalidAlgorithmParameterException(
          "unknown param type: " + params.getClass().getName());
    }

    engineInitInternal(opmode, key);
  }
  protected AlgorithmParameters engineGetParameters() {
    if (engineParams == null) {
      if (ivParam != null) {
        String name = cipher.getUnderlyingCipher().getAlgorithmName();

        if (name.indexOf('/') >= 0) {
          name = name.substring(0, name.indexOf('/'));
        }

        try {
          engineParams = AlgorithmParameters.getInstance(name, BouncyCastleProvider.PROVIDER_NAME);
          engineParams.init(ivParam.getIV());
        } catch (Exception e) {
          throw new RuntimeException(e.toString());
        }
      }
    }

    return engineParams;
  }
Example #29
0
    protected AlgorithmParameters engineGenerateParameters() {
      byte[] iv = new byte[8];

      if (random == null) {
        random = new SecureRandom();
      }

      random.nextBytes(iv);

      AlgorithmParameters params;

      try {
        params = createParametersInstance("DES");
        params.init(new IvParameterSpec(iv));
      } catch (Exception e) {
        throw new RuntimeException(e.getMessage());
      }

      return params;
    }
Example #30
0
    protected AlgorithmParameters engineGenerateParameters() {
      byte[] iv = new byte[8];

      if (random == null) {
        random = new SecureRandom();
      }

      random.nextBytes(iv);

      AlgorithmParameters params;

      try {
        params = AlgorithmParameters.getInstance("CAST5", BouncyCastleProvider.PROVIDER_NAME);
        params.init(new IvParameterSpec(iv));
      } catch (Exception e) {
        throw new RuntimeException(e.getMessage());
      }

      return params;
    }