Java Code Examples for javax.crypto.spec.SecretKeySpec

private static byte[] encrypt(byte[] raw,byte[] clear) throws Exception {
  SecretKeySpec skeySpec=new SecretKeySpec(raw,"AES");
  Cipher cipher=Cipher.getInstance("AES");
  cipher.init(Cipher.ENCRYPT_MODE,skeySpec);
  byte[] encrypted=cipher.doFinal(clear);
  return encrypted;
}
 

private static byte[] encrypt(byte[] raw,byte[] clear) throws Exception {
  SecretKeySpec skeySpec=new SecretKeySpec(raw,"AES");
  Cipher cipher=Cipher.getInstance("AES");
  cipher.init(Cipher.ENCRYPT_MODE,skeySpec);
  byte[] encrypted=cipher.doFinal(clear);
  return encrypted;
}
 

/** 
 * tests compatibilty with the google code HMAC_SHA1 signature.
 */
@Test public void testHMAC_SHA1_1() throws Exception {
  HMAC_SHA1 theirMethod=new HMAC_SHA1();
  String baseString="GET&http%3A%2F%2Flocalhost%3A8080%2Fgrailscrowd%2Foauth%2Frequest_token&oauth_consumer_key%3Dtonrconsumerkey%26oauth_nonce%3D1227967049787975000%26oauth_signature_method%3DHMAC-SHA1%26oauth_timestamp%3D1227967049%26oauth_version%3D1.0";
  theirMethod.setConsumerSecret("xxxxxx");
  theirMethod.setTokenSecret("");
  SecretKeySpec spec=new SecretKeySpec("xxxxxx&".getBytes("UTF-8"),HMAC_SHA1SignatureMethod.MAC_NAME);
  HMAC_SHA1SignatureMethod ourMethod=new HMAC_SHA1SignatureMethod(spec);
  String theirSignature=theirMethod.getSignature(baseString);
  String ourSignature=ourMethod.sign(baseString);
  assertEquals(theirSignature,ourSignature);
}
 

/** 
 * Create a new Mac object for the given key.
 * @param key Key to create a new Mac for.
 * @return New Mac object.
 * @throws InvalidKeyException Passed key is not valid
 * @throws EncFSUnsupportedException HMAC SHA-1 not supported by this runtime
 */
public static Mac newMac(Key key) throws InvalidKeyException, EncFSUnsupportedException {
  Mac hmac;
  try {
    hmac=Mac.getInstance("HmacSHA1");
  }
 catch (  NoSuchAlgorithmException e) {
    throw new EncFSUnsupportedException(e);
  }
  SecretKeySpec hmacKey=new SecretKeySpec(key.getEncoded(),"HmacSHA1");
  hmac.init(hmacKey);
  return hmac;
}
 

public String signature(String resource) throws NoSuchAlgorithmException, InvalidKeyException, UnsupportedEncodingException, URISyntaxException {
  SecretKeySpec sha1Key=new SecretKeySpec(key,"HmacSHA1");
  Mac mac=Mac.getInstance("HmacSHA1");
  mac.init(sha1Key);
  byte[] sigBytes=mac.doFinal(resource.getBytes());
  String signature=Base64.encodeBytes(sigBytes);
  signature=signature.replace('+','-');
  signature=signature.replace('/','_');
  return signature;
}
 

private static byte[] encrypt(byte[] raw,byte[] clear) throws Exception {
  SecretKeySpec skeySpec=new SecretKeySpec(raw,"AES");
  Cipher cipher=Cipher.getInstance("AES");
  cipher.init(Cipher.ENCRYPT_MODE,skeySpec);
  byte[] encrypted=cipher.doFinal(clear);
  return encrypted;
}
 

private String sign(String data,String key){
  try {
    SecretKeySpec signingKey=new SecretKeySpec(key.getBytes(ENCODING),SIGNATURE_METHOD);
    Mac mac=Mac.getInstance(SIGNATURE_METHOD);
    mac.init(signingKey);
    byte[] rawHmac=mac.doFinal(data.getBytes(ENCODING));
    return Base64.encodeBytes(rawHmac);
  }
 catch (  Exception e) {
    throw new RuntimeException(e);
  }
}
 

private Mac getHMAC(byte[] str){
  try {
    SecretKeySpec secret=new SecretKeySpec(str,"HmacSHA1");
    hmac.init(secret);
  }
 catch (  Exception e) {
    e.printStackTrace();
  }
  return hmac;
}
 

public static byte[] cipher(int mode,byte[] data,byte[] secret) throws NoSuchAlgorithmException, NoSuchPaddingException, InvalidKeyException, IllegalBlockSizeException, BadPaddingException {
  SecretKeySpec secretKeySpec=new SecretKeySpec(sha256(secret),"AES");
  Cipher c=Cipher.getInstance("AES");
  c.init(mode,secretKeySpec);
  return c.doFinal(data);
}
 

private static byte[] encrypt(byte[] raw,byte[] clear) throws Exception {
  SecretKeySpec skeySpec=new SecretKeySpec(raw,"AES");
  Cipher cipher=Cipher.getInstance("AES");
  cipher.init(Cipher.ENCRYPT_MODE,skeySpec);
  byte[] encrypted=cipher.doFinal(clear);
  return encrypted;
}
 

protected String checkSignature(final String queryKey,final String subject) throws QuerySecurityException {
  SecretKeySpec signingKey=new SecretKeySpec(queryKey.getBytes(),Hashes.Mac.HmacSHA1.toString());
  try {
    Mac mac=Mac.getInstance(Hashes.Mac.HmacSHA1.toString());
    mac.init(signingKey);
    byte[] rawHmac=mac.doFinal(subject.getBytes());
    return Base64.encode(rawHmac).replaceAll("=","");
  }
 catch (  Exception e) {
    LOG.error(e,e);
    throw new QuerySecurityException("Failed to compute signature");
  }
}
 

/** 
 * Decrypts the private key with given password. Does nothing if the key is not encrypted.
 * @param password password to decrypt the key with.
 * @throws GeneralSecurityException whenever an error occurs during decryption.
 */
public void decrypt(byte[] password) throws GeneralSecurityException {
  if (!isEncrypted()) {
    return;
  }
  byte[] enc=Base64.decode(this.encodedKey);
  SecretKeySpec key=getSecretKey(password,this.initializationVector.getIV());
  Cipher cipher=getCipher();
  cipher.init(Cipher.DECRYPT_MODE,key,this.initializationVector);
  enc=cipher.doFinal(enc);
  this.intKey=getKey(this.keyAlg,enc);
  this.keyData=enc;
  this.isEncrypted=false;
  this.encodedKey=null;
}
 

/** 
 * Gets the key.
 * @param EncryptionKey the encryption key
 * @param key the key
 * @return the key
 */
private byte[] getKey(final byte[] EncryptionKey,final byte[] key){
  final SecretKeySpec ds=new SecretKeySpec(EncryptionKey,"HmacSHA1");
  Mac m;
  try {
    m=Mac.getInstance("HmacSHA1");
    m.init(ds);
    return m.doFinal(key);
  }
 catch (  final Exception e) {
    e.printStackTrace();
  }
  return null;
}
 

public String signature(String resource) throws NoSuchAlgorithmException, InvalidKeyException, UnsupportedEncodingException, URISyntaxException {
  SecretKeySpec sha1Key=new SecretKeySpec(key,"HmacSHA1");
  Mac mac=Mac.getInstance("HmacSHA1");
  mac.init(sha1Key);
  byte[] sigBytes=mac.doFinal(resource.getBytes());
  String signature=Base64.encodeBytes(sigBytes);
  signature=signature.replace('+','-');
  signature=signature.replace('/','_');
  return signature;
}
 

public String signature(String resource) throws NoSuchAlgorithmException, InvalidKeyException, UnsupportedEncodingException, URISyntaxException {
  SecretKeySpec sha1Key=new SecretKeySpec(key,"HmacSHA1");
  Mac mac=Mac.getInstance("HmacSHA1");
  mac.init(sha1Key);
  byte[] sigBytes=mac.doFinal(resource.getBytes());
  String signature=Base64.encodeBytes(sigBytes);
  signature=signature.replace('+','-');
  signature=signature.replace('/','_');
  return signature;
}
 

public void init(byte[] key) throws Exception {
  if (key.length > defbsize) {
    byte[] tmp=new byte[defbsize];
    System.arraycopy(key,0,tmp,0,defbsize);
    key=tmp;
  }
  SecretKeySpec skey=new SecretKeySpec(key,algorithm);
  mac=SecurityUtils.getMac(algorithm);
  mac.init(skey);
}
 

/** 
 * Encrypt a plaintext String using a hmac_sha1 salt
 * @param key of type String
 * @param plaintext of type String
 * @return String the encrypted String of the given plaintext String
 * @throws SignatureException when the HMAC is unable to be generated
 */
public synchronized String encryptHMACSHA1(String key,String plaintext) throws java.security.SignatureException {
  String result;
  try {
    SecretKeySpec signingKey=new SecretKeySpec(key.getBytes(),"HmacSHA1");
    Mac mac=Mac.getInstance("HmacSHA1");
    mac.init(signingKey);
    byte[] rawHmac=mac.doFinal(plaintext.getBytes());
    result=new Base64().encodeToString(rawHmac);
  }
 catch (  Exception e) {
    throw new SignatureException("Failed to generate HMAC : " + e.getMessage());
  }
  return result;
}
 

private static byte[] encrypt(byte[] raw,byte[] clear) throws Exception {
  SecretKeySpec skeySpec=new SecretKeySpec(raw,"AES");
  Cipher cipher=Cipher.getInstance("AES");
  cipher.init(Cipher.ENCRYPT_MODE,skeySpec);
  byte[] encrypted=cipher.doFinal(clear);
  return encrypted;
}
 

/** 
 * Creates our AES cipher.
 */
public static Cipher getAESCipher(int mode,byte[] key){
  try {
    Cipher cipher=Cipher.getInstance("AES/CBC/PKCS5Padding");
    SecretKeySpec aesKey=new SecretKeySpec(key,"AES");
    cipher.init(mode,aesKey,IVPS);
    return cipher;
  }
 catch (  GeneralSecurityException gse) {
    log.warning("Failed to create cipher",gse);
  }
  return null;
}
 

public static String encrypt(String b64EncKey,String cleartext) throws Exception {
  byte[] encKey=DatatypeConverter.parseBase64Binary(b64EncKey);
  SecretKeySpec key=new SecretKeySpec(encKey,"AES");
  Cipher cipher=Cipher.getInstance("AES/ECB/PKCS5Padding");
  cipher.init(Cipher.ENCRYPT_MODE,key);
  return DatatypeConverter.printBase64Binary(cipher.doFinal(cleartext.getBytes("UTF-8")));
}
 

/** 
 * PRIVATE METHODS
 */
private String signRequest(String key,String resource) throws NoSuchAlgorithmException, InvalidKeyException, UnsupportedEncodingException, URISyntaxException {
  key=key.replace('-','+');
  key=key.replace('_','/');
  byte[] base64edKey=Base64.decodeBase64(key.getBytes());
  SecretKeySpec sha1Key=new SecretKeySpec(base64edKey,"HmacSHA1");
  Mac mac=Mac.getInstance("HmacSHA1");
  mac.init(sha1Key);
  byte[] sigBytes=mac.doFinal(resource.getBytes());
  String signature=new String(Base64.encodeBase64(sigBytes));
  signature=signature.replace('+','-');
  signature=signature.replace('/','_');
  return resource + "&signature=" + signature;
}
 

@Test public void testEncryptSymmetricKeyWithPublicKey_shouldBeTheSameWhenDecryptedWithPrivateKey() throws Exception {
  SecretKey secretKey=CipherUtils.generateKey("AES",128);
  byte[] encoded=secretKey.getEncoded();
  byte[] encryptedKey=CipherUtils.encrypt(encoded,generatedPublickey);
  byte[] decryptKey=CipherUtils.decrypt(encryptedKey,generatedPrivatekey);
  SecretKeySpec secretKeySpec=new SecretKeySpec(decryptKey,"AES");
  assertThat(secretKeySpec,is(secretKey));
}
 

private static byte[] encrypt(byte[] raw,byte[] clear) throws Exception {
  SecretKeySpec skeySpec=new SecretKeySpec(raw,"AES");
  Cipher cipher=Cipher.getInstance("AES");
  cipher.init(Cipher.ENCRYPT_MODE,skeySpec);
  byte[] encrypted=cipher.doFinal(clear);
  return encrypted;
}
 

public static byte[] cipher(int mode,byte[] data,byte[] secret) throws NoSuchAlgorithmException, NoSuchPaddingException, InvalidKeyException, IllegalBlockSizeException, BadPaddingException {
  SecretKeySpec secretKeySpec=new SecretKeySpec(sha256(secret),"AES");
  Cipher c=Cipher.getInstance("AES");
  c.init(mode,secretKeySpec);
  return c.doFinal(data);
}
 

public AesBytesEncryptor(String password,CharSequence salt,BytesKeyGenerator ivGenerator){
  PBEKeySpec keySpec=new PBEKeySpec(password.toCharArray(),Hex.decode(salt),1024,256);
  SecretKey secretKey=newSecretKey("PBKDF2WithHmacSHA1",keySpec);
  this.secretKey=new SecretKeySpec(secretKey.getEncoded(),"AES");
  encryptor=newCipher(AES_ALGORITHM);
  decryptor=newCipher(AES_ALGORITHM);
  this.ivGenerator=ivGenerator != null ? ivGenerator : NULL_IV_GENERATOR;
}
 

private byte[] encrypt(String base,String key){
  try {
    SecretKeySpec secretKeySpec=new SecretKeySpec(key.getBytes(),HMAC_SHA256_MAC_NAME);
    Mac mac=Mac.getInstance(HMAC_SHA256_MAC_NAME);
    mac.init(secretKeySpec);
    return mac.doFinal(base.getBytes());
  }
 catch (  NoSuchAlgorithmException e) {
    throw new IllegalStateException(e);
  }
catch (  InvalidKeyException e) {
    throw new IllegalStateException(e);
  }
}
 

private Cipher getCipher(int mode,SecretKey secretKey,AlgorithmParameterSpec parameters) throws Exception {
  Cipher cipher=Cipher.getInstance("AES/CBC/PKCS5Padding");
  SecretKeySpec secretKeySpec=new SecretKeySpec(secretKey.getEncoded(),"AES");
  cipher.init(mode,secretKeySpec,parameters);
  return cipher;
}
 

/** 
 * Computes RFC 2104-compliant HMAC signature.
 * @param data The data to be signed.
 * @param key The signing key.
 * @return The Base64-encoded RFC 2104-compliant HMAC signature.
 * @throws java.security.SignatureException when signature generation fails
 */
public String calculateRFC2104HMAC(String data,String key) throws java.security.SignatureException {
  String result;
  try {
    SecretKeySpec signingKey=new SecretKeySpec(key.getBytes(),HMAC_SHA1_ALGORITHM);
    Mac mac=Mac.getInstance(HMAC_SHA1_ALGORITHM);
    mac.init(signingKey);
    byte[] rawHmac=mac.doFinal(data.getBytes());
    result=new String(Base64.encodeBase64(rawHmac));
  }
 catch (  Exception e) {
    throw new SignatureException("Failed to generate HMAC",e);
  }
  return result;
}
 

private MasterCipher getMasterCipherForSecret(BigInteger secret){
  byte[] secretBytes=secret.toByteArray();
  SecretKeySpec cipherKey=deriveCipherKey(secretBytes);
  SecretKeySpec macKey=deriveMacKey(secretBytes);
  MasterSecret masterSecret=new MasterSecret(cipherKey,macKey);
  return new MasterCipher(masterSecret);
}
 

public static String aes_encrypt(String password,String plaintext) throws Exception {
  byte[] secret_key=generateKey(password.getBytes());
  byte[] clear=plaintext.getBytes();
  SecretKeySpec secretKeySpec=new SecretKeySpec(secret_key,CIPHER_ALGORITHM);
  Cipher cipher=Cipher.getInstance(CIPHER_ALGORITHM);
  cipher.init(Cipher.ENCRYPT_MODE,secretKeySpec);
  byte[] encrypted=cipher.doFinal(clear);
  String encryptedString=Base64.encodeToString(encrypted,Base64.DEFAULT);
  return encryptedString;
}
 

/** 
 * Accepts a hexadecimal encoded version of the encrypted data and decrypts it.
 * @param encrypted hexadecimal encoded version of the encrypted data
 * @param keyString The key to use to decrypt the data.
 * @return Decrypted version.
 * @throws UnsupportedOperationException If there is a cryptographic error.
 */
public static String fromAES(final String encrypted,String keyString){
  final SecretKeySpec skeySpec=new SecretKeySpec(new BigInteger(keyString,16).toByteArray(),"AES");
  try {
    final Cipher cipher=Cipher.getInstance("AES");
    cipher.init(Cipher.DECRYPT_MODE,skeySpec);
    return new String(cipher.doFinal(new BigInteger(encrypted,16).toByteArray()));
  }
 catch (  final InvalidKeyException e) {
    throw new UnsupportedOperationException(e);
  }
catch (  final IllegalBlockSizeException e) {
    throw new UnsupportedOperationException(e);
  }
catch (  final BadPaddingException e) {
    throw new UnsupportedOperationException(e);
  }
catch (  final NoSuchAlgorithmException e) {
    throw new UnsupportedOperationException(e);
  }
catch (  final NoSuchPaddingException e) {
    throw new UnsupportedOperationException(e);
  }
}
 

public static String sign(String content,String key){
  try {
    byte[] data=content.getBytes(Constants.ENCODING_FORMAT);
    Mac mac=Mac.getInstance(Constants.SIGNATURE_METHOD);
    mac.init(new SecretKeySpec(key.getBytes(Constants.ENCODING_FORMAT),Constants.SIGNATURE_METHOD));
    byte[] signature=Base64.encodeBase64(mac.doFinal(data));
    return new String(signature,Constants.ENCODING_FORMAT);
  }
 catch (  Exception exception) {
    log.log(Level.SEVERE,"Exception during sign",exception);
  }
  return null;
}
 

public static String sign(String content,String key){
  try {
    byte[] data=content.getBytes(Constants.ENCODING_FORMAT);
    Mac mac=Mac.getInstance(Constants.SIGNATURE_METHOD);
    mac.init(new SecretKeySpec(key.getBytes(Constants.ENCODING_FORMAT),Constants.SIGNATURE_METHOD));
    char[] signature=Hex.encodeHex(mac.doFinal(data));
    return new String(signature);
  }
 catch (  Exception exception) {
    log.log(Level.SEVERE,"Exception during sign",exception);
  }
  return null;
}
 

public String decryptValue(String toDecrypt,String passphrase){
  log.info("decrypt called");
  if (!toDecrypt.startsWith("$1$")) {
    log.debug("this is not an encrypted string");
    return toDecrypt;
  }
  toDecrypt=toDecrypt.substring(3);
  try {
    Cipher cipher;
    cipher=Cipher.getInstance("AES/CBC/PKCS5Padding");
    String ivString=passphrase + passphrase;
    String iv=DigestUtils.sha256Hex(ivString);
    String passphraseDigest=DigestUtils.sha256Hex(passphrase);
    SecretKeySpec spec=new SecretKeySpec(Arrays.copyOfRange(passphraseDigest.getBytes(),0,32),"AES");
    cipher.init(Cipher.DECRYPT_MODE,spec,new IvParameterSpec(iv.getBytes(),0,16));
    log.info("gh10");
    byte[] b64bytes=Base64.decodeBase64(toDecrypt);
    String plaintext=new String(cipher.doFinal(b64bytes));
    return plaintext;
  }
 catch (  Exception e) {
    log.info("Failure trying to decrypt" + toDecrypt,e);
    throw new RuntimeException(e);
  }
}
 

private static Key getSecretKey(String secretKeyAlgorithm,String secretKey,String salt) throws Exception {
  SecretKeyFactory factory=SecretKeyFactory.getInstance(SECRET_KEY_FACTORY_ALGORITHM);
  KeySpec spec=new PBEKeySpec(secretKey.toCharArray(),char2byte(salt),65536,128);
  SecretKey tmp=factory.generateSecret(spec);
  SecretKey secret=new SecretKeySpec(tmp.getEncoded(),secretKeyAlgorithm);
  return secret;
}
 

private byte[] encrypt(byte[] secretKey,String data) throws InvalidKeyException {
  byte[] encryptedData=null;
  try {
    Cipher aescf=Cipher.getInstance("AES/CBC/PKCS5Padding");
    IvParameterSpec ivspec=new IvParameterSpec(new byte[16]);
    aescf.init(Cipher.ENCRYPT_MODE,new SecretKeySpec(secretKey,"AES"),ivspec);
    encryptedData=aescf.doFinal(data.getBytes(UTF8));
  }
 catch (  Exception e) {
    LOG.log(Level.SEVERE,"Exception encrypting data",e);
  }
  return encryptedData;
}
 

public static SecretKey keyExchange(ObjectInputStream in,ObjectOutputStream out) throws IllegalBlockSizeException, BadPaddingException, InvalidKeyException, NoSuchAlgorithmException, IOException, ClassNotFoundException, NoSuchPaddingException {
  KeyPairGenerator gen=KeyPairGenerator.getInstance("RSA");
  gen.initialize(1024,new SecureRandom());
  KeyPair keys=gen.generateKeyPair();
  PublicKey publicKey=keys.getPublic();
  PrivateKey privateKey=keys.getPrivate();
  out.writeObject(new KeyExchangeClient(publicKey));
  out.flush();
  KeyExchangeServer response=(KeyExchangeServer)in.readObject();
  Cipher decryptor=Cipher.getInstance("RSA/ECB/PKCS1Padding");
  decryptor.init(Cipher.DECRYPT_MODE,privateKey);
  byte[] sessionKeyEncoded=decryptor.doFinal(response.getCryptedSessionKey());
  return new SecretKeySpec(sessionKeyEncoded,"DES");
}
 

/** 
 * Given a string key, either trim it down so its an appropriate size, or pad it to make it long enough
 * @param theKey the key use
 * @return a secret key based on the provided key string.
 */
private static SecretKey makeGoodKey(String theKey){
  String aKey=theKey;
  if (aKey.length() > 8) {
    aKey=aKey.substring(0,8);
  }
 else   if (aKey.length() < 8) {
    while (aKey.length() < 8) {
      aKey+="0";
    }
  }
  return new SecretKeySpec(aKey.getBytes(),"DES");
}
 

private static String sign(OAuthToken consumerOAuthToken,OAuthToken accessOAuthToken,MethodType methodType,String url,List<EncodedPair> oauthParams) throws NoSuchAlgorithmException, UnsupportedEncodingException, InvalidKeyException {
  List<EncodedPair> sorted=sortByNameAndValues(oauthParams);
  String signUri=constructRequestURL(url);
  String signParams=join(sorted,'&','=',false,false);
  String signature=consumerOAuthToken.getSecret() + "&" + accessOAuthToken.getSecret();
  Mac mac=Mac.getInstance(SIGN_METH_4_J);
  mac.init(new SecretKeySpec(signature.getBytes(ENC),SIGN_METH_4_J));
  String data=methodType.name() + "&" + encode(signUri,ENC)+ "&"+ encode(signParams,ENC);
  String encoded=new String(Base64.encodeToByte(mac.doFinal(data.getBytes(ENC))),ENC);
  LOGGER.debug("Signature[data=\"%s\",signature=\"%s\",result=\"%s\"]",data,signature,encoded);
  return encoded;
}
 

/** 
 * The only public function and is *the* function of this class. It generates the k_1, k_2, etc. from  parameters Friend, f, and time or whatever it is you want to "encrypt", toEncrypt.
 */
public byte[] generate_k(String dhkey,String toEncrypt){
  byte[] retVal;
  try {
    mCipher=Cipher.getInstance("AES");
    MessageDigest hasher=MessageDigest.getInstance("SHA-256");
    byte[] key256=hasher.digest(dhkey.getBytes());
    SecretKeySpec K=new SecretKeySpec(key256,"AES");
    mCipher.init(Cipher.ENCRYPT_MODE,K);
    try {
      retVal=mCipher.doFinal(toEncrypt.getBytes());
      return retVal;
    }
 catch (    Exception e) {
    }
  }
 catch (  Exception e) {
  }
  return null;
}
 

protected static String sign(String content,String key) throws InvalidKeySpecException, NoSuchAlgorithmException, InvalidKeyException, IllegalStateException {
  Mac mac=Mac.getInstance(MAC_ALGORITHM);
  SecretKey skey=new SecretKeySpec(key.getBytes(),KEY_ALGORITHM);
  mac.init(skey);
  mac.update(content.getBytes());
  return new String(Base64.encodeBase64((mac.doFinal())));
}
 

public static byte[] sha256(final byte[] message,final byte[] key){
  final Mac mac;
  try {
    mac=Mac.getInstance("HmacSHA256");
    mac.init(new SecretKeySpec(key,"HmacSHA256"));
  }
 catch (  Exception e) {
    throw new RuntimeException(e);
  }
  return mac.doFinal(message);
}
 

/** 
 * Computes RFC 2104-compliant HMAC signature.
 * @param data the data to be signed
 * @return signature
 * @see <a href="http://oauth.net/core/1.0/#rfc.section.9.2.1">OAuth Core - 9.2.1.  Generating Signature</a>
 */
String generateSignature(String data,OAuthToken token){
  byte[] byteHMAC=null;
  try {
    Mac mac=Mac.getInstance(HMAC_SHA1);
    SecretKeySpec spec;
    if (null == token) {
      String oauthSignature=encode(consumerSecret) + "&";
      spec=new SecretKeySpec(oauthSignature.getBytes(),HMAC_SHA1);
    }
 else {
      if (null == token.getSecretKeySpec()) {
        String oauthSignature=encode(consumerSecret) + "&" + encode(token.getTokenSecret());
        spec=new SecretKeySpec(oauthSignature.getBytes(),HMAC_SHA1);
        token.setSecretKeySpec(spec);
      }
      spec=token.getSecretKeySpec();
    }
    mac.init(spec);
    byteHMAC=mac.doFinal(data.getBytes());
  }
 catch (  InvalidKeyException e) {
    e.printStackTrace();
  }
catch (  NoSuchAlgorithmException ignore) {
  }
  return new BASE64Encoder().encode(byteHMAC);
}
 

public byte[] sha256Hmac(byte[] b,byte[] key,int length) throws OtrCryptoException {
  SecretKeySpec keyspec=new SecretKeySpec(key,"HmacSHA256");
  javax.crypto.Mac mac;
  try {
    mac=javax.crypto.Mac.getInstance("HmacSHA256");
  }
 catch (  NoSuchAlgorithmException e) {
    throw new OtrCryptoException(e);
  }
  try {
    mac.init(keyspec);
  }
 catch (  InvalidKeyException e) {
    throw new OtrCryptoException(e);
  }
  byte[] macBytes=mac.doFinal(b);
  if (length > 0) {
    byte[] bytes=new byte[length];
    ByteBuffer buff=ByteBuffer.wrap(macBytes);
    buff.get(bytes);
    return bytes;
  }
 else {
    return macBytes;
  }
}
 

/** 
 * This method is called whenever a key needs to be generated.
 * @return Key the encryption key
 */
public Key generateKey(){
  try {
    SecureRandom random=SecureRandom.getInstance(this.prngAlgorithm,this.provider);
    byte[] iv=new byte[16];
    random.nextBytes(iv);
    KeyGenerator kgen=KeyGenerator.getInstance(algorithm);
    kgen.init(keySize,random);
    SecretKey skey=kgen.generateKey();
    byte[] raw=skey.getEncoded();
    SecretKeySpec skeySpec=new SecretKeySpec(raw,algorithm);
    Key key=new Key();
    key.setKey(skeySpec);
    key.setInitVector(iv);
    return key;
  }
 catch (  Exception e) {
    String errorMessage=HDIVUtil.getMessage("key.factory.generate",e.getMessage());
    throw new HDIVException(errorMessage,e);
  }
}
 

private Cipher getCipher(byte[] key) throws NoSuchAlgorithmException, NoSuchPaddingException, InvalidKeyException {
  final Cipher ecipher=Cipher.getInstance("DES/ECB/NoPadding");
  key=setupKey(key);
  ecipher.init(Cipher.ENCRYPT_MODE,new SecretKeySpec(key,"DES"));
  return ecipher;
}
 

private void init(){
  try {
    mCipher=Cipher.getInstance("AES/CBC/PKCS5PADDING");
    mKeySpec=new SecretKeySpec(mKey,"AES");
  }
 catch (  Exception e) {
    e.printStackTrace();
  }
}
 

private static Cipher getCipher(int mode){
  final byte[] encodedKey={28,-9,-23,35,-93,-47,-28,55,-83,-82,101,-79,36,59,77,-121};
  Cipher cipher=null;
  try {
    cipher=Cipher.getInstance("AES");
    SecretKeySpec spec=new SecretKeySpec(encodedKey,"AES");
    cipher.init(mode,spec);
    return cipher;
  }
 catch (  InvalidKeyException exp) {
    exp.printStackTrace();
  }
catch (  NoSuchAlgorithmException exp) {
    exp.printStackTrace();
  }
catch (  NoSuchPaddingException exp) {
    exp.printStackTrace();
  }
  return null;
}
 

@Test public void testEncryptDESKeyThrowsNullPointerException() throws Throwable {
  byte[] bytes=new byte[1];
  Key encryptingKey=new SecretKeySpec(bytes,"testJCEHandlerParam2");
  try {
    new JCEHandler((Provider)null).encryptDESKey((short)100,null,encryptingKey);
    fail("Expected NullPointerException to be thrown");
  }
 catch (  NullPointerException ex) {
    assertNull("ex.getMessage()",ex.getMessage());
    assertEquals("(SecretKeySpec) encryptingKey.getAlgorithm()","testJCEHandlerParam2",((SecretKeySpec)encryptingKey).getAlgorithm());
  }
}
 

/** 
 * Calls the  {@link #init(javax.crypto.Cipher,int,java.security.Key)} and then{@link #crypt(javax.crypto.Cipher,byte[])}.  Ensures that the key is never null by using the {@link #getKey() default key} if the method argument key is <code>null</code>.
 * @param bytes the bytes to crypt
 * @param mode  the JDK Cipher mode
 * @param key   the key to use to do the cryption.  If <code>null</code> the {@link #getKey() default key} will be used.
 * @return the resulting crypted byte array
 */
protected byte[] crypt(byte[] bytes,int mode,byte[] key){
  javax.crypto.Cipher cipher=newCipherInstance();
  java.security.Key jdkKey;
  if (key == null) {
    jdkKey=getKey();
  }
 else {
    jdkKey=new SecretKeySpec(key,ALGORITHM);
  }
  init(cipher,mode,jdkKey);
  return crypt(cipher,bytes);
}
 

/** 
 * Creates HmacSha1.
 * @param secretKey SecretKey
 * @param data target data
 * @return HmacSha1
 * @throws KarotzException Illegal encoding.
 */
public static String doHmacSha1(String secretKey,String data) throws KarotzException {
  String hmacSha1;
  try {
    Mac mac=Mac.getInstance("HmacSHA1");
    SecretKeySpec secret=new SecretKeySpec(secretKey.getBytes("ASCII"),"HmacSHA1");
    mac.init(secret);
    byte[] digest=mac.doFinal(data.getBytes("UTF-8"));
    hmacSha1=new String(Base64.encodeBase64(digest),"ASCII");
  }
 catch (  IllegalStateException e) {
    throw new KarotzException(e);
  }
catch (  InvalidKeyException e) {
    throw new KarotzException(e);
  }
catch (  NoSuchAlgorithmException e) {
    throw new KarotzException(e);
  }
catch (  UnsupportedEncodingException e) {
    throw new KarotzException(e);
  }
  return hmacSha1;
}
 

/** 
 * Generate appropriate cipher based on KeePass 2.x UUID's
 * @param uuid
 * @return
 * @throws NoSuchPaddingException 
 * @throws NoSuchAlgorithmException 
 * @throws InvalidAlgorithmParameterException 
 * @throws InvalidKeyException 
 */
public static Cipher getInstance(UUID uuid,byte[] key,byte[] IV) throws NoSuchAlgorithmException, NoSuchPaddingException, InvalidKeyException, InvalidAlgorithmParameterException {
  if (uuid.equals(AES_CIPHER)) {
    Cipher cipher=CipherFactory.getInstance("AES/CBC/PKCS5Padding");
    cipher.init(Cipher.DECRYPT_MODE,new SecretKeySpec(key,"AES"),new IvParameterSpec(IV));
    return cipher;
  }
  throw new NoSuchAlgorithmException("UUID unrecognized.");
}
 

public String encrypt(String text,String passphrase,int keylen){
  RC2ParameterSpec parm=new RC2ParameterSpec(keylen);
  try {
    MessageDigest md=MessageDigest.getInstance("MD5");
    md.update(passphrase.getBytes(getCharset()));
    SecretKeySpec skeySpec=new SecretKeySpec(md.digest(),"RC2");
    Cipher cipher=Cipher.getInstance("RC2/ECB/NoPadding");
    cipher.init(Cipher.ENCRYPT_MODE,skeySpec,parm);
    byte[] newBytes=encodeStringNew(text);
    byte[] d=cipher.doFinal(newBytes);
    return Base64.encodeBytes(d);
  }
 catch (  NoSuchAlgorithmException e) {
    e.printStackTrace();
  }
catch (  NoSuchPaddingException e) {
    e.printStackTrace();
  }
catch (  InvalidKeyException e) {
    e.printStackTrace();
  }
catch (  InvalidAlgorithmParameterException e) {
    e.printStackTrace();
  }
catch (  IllegalBlockSizeException e) {
    e.printStackTrace();
  }
catch (  BadPaddingException e) {
    e.printStackTrace();
  }
  return null;
}
 

/** 
 * Computes RFC 2104-compliant HMAC signature.
 * @param data the data to be signed
 * @return signature
 * @see <a href="http://oauth.net/core/1.0/#rfc.section.9.2.1">OAuth Core - 9.2.1.  Generating Signature</a>
 */
String generateSignature(String data,OAuthToken token){
  byte[] byteHMAC=null;
  try {
    Mac mac=Mac.getInstance(HMAC_SHA1);
    SecretKeySpec spec;
    if (null == token) {
      String oauthSignature=encode(consumerSecret) + "&";
      spec=new SecretKeySpec(oauthSignature.getBytes(),HMAC_SHA1);
    }
 else {
      if (null == token.getSecretKeySpec()) {
        String oauthSignature=encode(consumerSecret) + "&" + encode(token.getTokenSecret());
        spec=new SecretKeySpec(oauthSignature.getBytes(),HMAC_SHA1);
        token.setSecretKeySpec(spec);
      }
      spec=token.getSecretKeySpec();
    }
    mac.init(spec);
    byteHMAC=mac.doFinal(data.getBytes());
  }
 catch (  InvalidKeyException e) {
    e.printStackTrace();
  }
catch (  NoSuchAlgorithmException ignore) {
  }
  return new BASE64Encoder().encode(byteHMAC);
}
 

/** 
 * Computes RFC 2104-compliant HMAC signature.
 * @param data  the data to be signed
 * @param token the token
 * @return signature
 * @see <a href="http://oauth.net/core/1.0a/#rfc.section.9.2.1">OAuth Core - 9.2.1.  Generating Signature</a>
 */
String generateSignature(String data,OAuthToken token){
  byte[] byteHMAC=null;
  try {
    Mac mac=Mac.getInstance(HMAC_SHA1);
    SecretKeySpec spec;
    if (null == token) {
      String oauthSignature=HttpParameter.encode(consumerSecret) + "&";
      spec=new SecretKeySpec(oauthSignature.getBytes(),HMAC_SHA1);
    }
 else {
      spec=token.getSecretKeySpec();
      if (null == spec) {
        String oauthSignature=HttpParameter.encode(consumerSecret) + "&" + HttpParameter.encode(token.getTokenSecret());
        spec=new SecretKeySpec(oauthSignature.getBytes(),HMAC_SHA1);
        token.setSecretKeySpec(spec);
      }
    }
    mac.init(spec);
    byteHMAC=mac.doFinal(data.getBytes());
  }
 catch (  InvalidKeyException ike) {
    logger.error("Failed initialize \"Message Authentication Code\" (MAC)",ike);
    throw new AssertionError(ike);
  }
catch (  NoSuchAlgorithmException nsae) {
    logger.error("Failed to get HmacSHA1 \"Message Authentication Code\" (MAC)",nsae);
    throw new AssertionError(nsae);
  }
  return BASE64Encoder.encode(byteHMAC);
}
 

public static String encryptLMPassword(String password) throws Exception {
  if (password == null)   return null;
  byte[] bytes=password.toUpperCase().getBytes("UTF-8");
  if (bytes.length != 14) {
    byte[] b=new byte[14];
    for (int i=0; i < bytes.length && i < 14; i++)     b[i]=bytes[i];
    bytes=b;
  }
  byte[] key1=convert(bytes,0);
  byte[] key2=convert(bytes,7);
  byte[] magic=new BigInteger("4B47532140232425",16).toByteArray();
  SecretKeySpec spec1=new SecretKeySpec(key1,"DES");
  Cipher cipher1=Cipher.getInstance("DES");
  cipher1.init(Cipher.ENCRYPT_MODE,spec1);
  byte[] result1=cipher1.doFinal(magic);
  SecretKeySpec spec2=new SecretKeySpec(key2,"DES");
  Cipher cipher2=Cipher.getInstance("DES");
  cipher2.init(Cipher.ENCRYPT_MODE,spec2);
  byte[] result2=cipher2.doFinal(magic);
  System.arraycopy(result2,0,result1,8,8);
  return BinaryUtil.encode(BinaryUtil.BIG_INTEGER,result1).toUpperCase();
}
 

/** 
 * Calculates an HMAC SHA256 hash using a default key length.
 * @param input
 * @param key
 * @return hmac hashed bytes
 */
public byte[] calculateHMAC_SHA256(byte[] input,byte[] key){
  byte[] output=null;
  try {
    hmacSHA256.init(new SecretKeySpec(key,"HmacSHA256"));
    output=hmacSHA256.doFinal(input);
  }
 catch (  InvalidKeyException e) {
    log.error("Invalid key",e);
  }
  return output;
}
 

public byte[] calculateHMAC_SHA256(byte[] input,byte[] key){
  byte[] output=null;
  try {
    hmacSHA256.init(new SecretKeySpec(key,"HmacSHA256"));
    output=hmacSHA256.doFinal(input);
  }
 catch (  InvalidKeyException e) {
    log.error("Invalid key",e);
  }
  return output;
}
 

/** 
 * Calculates an HMAC SHA256 hash using a default key length.
 * @param input
 * @param key
 * @return hmac hashed bytes
 */
public byte[] calculateHMAC_SHA256(byte[] input,byte[] key){
  byte[] output=null;
  try {
    hmacSHA256.init(new SecretKeySpec(key,"HmacSHA256"));
    output=hmacSHA256.doFinal(input);
  }
 catch (  InvalidKeyException e) {
    log.error("Invalid key",e);
  }
  return output;
}
 

public static String sign(String message){
  byte[] key=privatekey.getBytes();
  if (key.length == 0) {
    return message;
  }
  try {
    Mac mac=Mac.getInstance("HmacSHA1");
    SecretKeySpec signingKey=new SecretKeySpec(key,"HmacSHA1");
    mac.init(signingKey);
    byte[] messageBytes=message.getBytes("utf-8");
    byte[] result=mac.doFinal(messageBytes);
    int len=result.length;
    char[] hexChars=new char[len * 2];
    for (int charIndex=0, startIndex=0; charIndex < hexChars.length; ) {
      int bite=result[startIndex++] & 0xff;
      hexChars[charIndex++]=HEX_CHARS[bite >> 4];
      hexChars[charIndex++]=HEX_CHARS[bite & 0xf];
    }
    return new String(hexChars);
  }
 catch (  Exception ex) {
    throw new RuntimeException(ex);
  }
}
 

protected String encryptText(String text,XWikiContext context){
  try {
    String secretKey=null;
    secretKey=context.getWiki().Param("xwiki.authentication.encryptionKey");
    secretKey=secretKey.substring(0,24);
    if (secretKey != null) {
      SecretKeySpec key=new SecretKeySpec(secretKey.getBytes(),"TripleDES");
      Cipher cipher=Cipher.getInstance("TripleDES");
      cipher.init(Cipher.ENCRYPT_MODE,key);
      byte[] encrypted=cipher.doFinal(text.getBytes());
      String encoded=Base64.encode(encrypted);
      return encoded.replaceAll("=","_");
    }
 else {
      LOG.error("Encryption key not defined");
    }
  }
 catch (  Exception e) {
    LOG.error("Failed to encrypt text",e);
  }
  return null;
}
 

public String getAuth() throws IOException {
  try {
    Calendar calendar=Calendar.getInstance();
    SimpleDateFormat format=new SimpleDateFormat("yyyy-MM-dd-HH");
    format.setTimeZone(TimeZone.getTimeZone("UTC"));
    String key=PluginImpl.get().getUsername() + ":" + PluginImpl.get().getApiKey()+ ":"+ format.format(calendar.getTime());
    byte[] keyBytes=key.getBytes();
    SecretKeySpec sks=new SecretKeySpec(keyBytes,HMAC_KEY);
    Mac mac=Mac.getInstance(sks.getAlgorithm());
    mac.init(sks);
    byte[] hmacBytes=mac.doFinal(id.getBytes());
    byte[] hexBytes=new Hex().encode(hmacBytes);
    return new String(hexBytes,"ISO-8859-1");
  }
 catch (  NoSuchAlgorithmException e) {
    throw new IOException("Could not generate Sauce-OnDemand access code",e);
  }
catch (  InvalidKeyException e) {
    throw new IOException("Could not generate Sauce-OnDemand access code",e);
  }
catch (  UnsupportedEncodingException e) {
    throw new IOException("Could not generate Sauce-OnDemand access code",e);
  }
}
 

public void init(byte[] P){
  try {
    mac.init(new SecretKeySpec(P,macAlgorithm));
  }
 catch (  InvalidKeyException e) {
    throw new RuntimeException(e);
  }
}
 

private javax.crypto.Cipher initNewCipher(int jcaCipherMode,byte[] key,byte[] iv,boolean streaming) throws CryptoException {
  javax.crypto.Cipher cipher=newCipherInstance(streaming);
  java.security.Key jdkKey=new SecretKeySpec(key,getAlgorithmName());
  IvParameterSpec ivSpec=null;
  if (iv != null && iv.length > 0) {
    ivSpec=new IvParameterSpec(iv);
  }
  init(cipher,jcaCipherMode,jdkKey,ivSpec,getSecureRandom());
  return cipher;
}
 

private String generateSig(HttpRequest request,HttpParameters requestParameters) throws Exception {
  String keyString=OAuth.percentEncode(getConsumerSecret()) + '&' + OAuth.percentEncode(getTokenSecret());
  byte[] keyBytes=keyString.getBytes(OAuth.ENCODING);
  SecretKey key=new SecretKeySpec(keyBytes,MAC_NAME);
  Mac mac=Mac.getInstance(MAC_NAME);
  mac.init(key);
  String sbs=new SignatureBaseString(request,requestParameters).generate();
  return base64(mac.doFinal(sbs.getBytes(OAuth.ENCODING)));
}
 

private String signToken(Content token,String sharedKey,PrincipalValidatorPlugin plugin){
  try {
    MessageDigest md=MessageDigest.getInstance("SHA-512");
    byte[] input=sharedKey.getBytes("UTF-8");
    byte[] data=md.digest(input);
    SecretKeySpec key=new SecretKeySpec(data,HMAC_SHA512);
    return getHmac(token,plugin.getProtectedFields(),key);
  }
 catch (  InvalidKeyException e) {
    LOGGER.warn(e.getMessage());
    LOGGER.debug(e.getMessage(),e);
    return null;
  }
catch (  NoSuchAlgorithmException e) {
    LOGGER.warn(e.getMessage());
    LOGGER.debug(e.getMessage(),e);
    return null;
  }
catch (  IllegalStateException e) {
    LOGGER.warn(e.getMessage());
    LOGGER.debug(e.getMessage(),e);
    return null;
  }
catch (  UnsupportedEncodingException e) {
    LOGGER.warn(e.getMessage());
    LOGGER.debug(e.getMessage(),e);
    return null;
  }
}
 

public AndroidAesBytesEncryptor(String password,CharSequence salt,BytesKeyGenerator ivGenerator){
  PBEKeySpec keySpec=new PBEKeySpec(password.toCharArray(),Hex.decode(salt),1024,256);
  SecretKey secretKey=newSecretKey("PBEWITHSHA256AND256BITAES-CBC-BC",keySpec);
  this.secretKey=new SecretKeySpec(secretKey.getEncoded(),"AES");
  encryptor=newCipher(AES_ALGORITHM);
  decryptor=newCipher(AES_ALGORITHM);
  this.ivGenerator=ivGenerator;
}
 

/** 
 * Encrypts or decrypts a message. The encryption/decryption mode depends on the configuration of the mode parameter.
 * @param key a base64 encoded version of the symmetric key
 * @param initializationVector a base64 encoded version of theinitialization vector
 * @param message if in encryption mode, the clear-text message to encrypt,otherwise a base64 encoded version of the message to decrypt
 * @return if in encryption mode, returns a base64 encoded version of theencrypted message, otherwise returns the decrypted clear-text message
 * @throws SymmetricEncryptionException on runtime errors
 * @see #setMode(com.google.code.springcryptoutils.core.cipher.Mode)
 */
public String encrypt(String key,String initializationVector,String message){
  try {
    IvParameterSpec initializationVectorSpec=new IvParameterSpec(Base64.decodeBase64(initializationVector));
    final SecretKeySpec keySpec=new SecretKeySpec(Base64.decodeBase64(key),keyAlgorithm);
    final Cipher cipher=(((provider == null) || (provider.length() == 0)) ? Cipher.getInstance(cipherAlgorithm) : Cipher.getInstance(cipherAlgorithm,provider));
    byte[] messageAsByteArray;
switch (mode) {
case ENCRYPT:
      cipher.init(Cipher.ENCRYPT_MODE,keySpec,initializationVectorSpec);
    messageAsByteArray=message.getBytes(charsetName);
  final byte[] encryptedMessage=cipher.doFinal(messageAsByteArray);
return new String(Base64.encodeBase64(encryptedMessage,chunkOutput));
case DECRYPT:
cipher.init(Cipher.DECRYPT_MODE,keySpec,initializationVectorSpec);
messageAsByteArray=Base64.decodeBase64(message);
final byte[] decryptedMessage=cipher.doFinal(messageAsByteArray);
return new String(decryptedMessage,charsetName);
default :
return null;
}
}
 catch (Exception e) {
throw new SymmetricEncryptionException("error encrypting/decrypting message; mode=" + mode,e);
}
}
 

private String sign(String signatureBaseString,String key){
  try {
    Mac mac=Mac.getInstance(HMAC_SHA1_MAC_NAME);
    SecretKeySpec spec=new SecretKeySpec(key.getBytes(),HMAC_SHA1_MAC_NAME);
    mac.init(spec);
    byte[] text=signatureBaseString.getBytes(UTF8_CHARSET_NAME);
    byte[] signatureBytes=mac.doFinal(text);
    signatureBytes=Base64.encode(signatureBytes);
    String signature=new String(signatureBytes,UTF8_CHARSET_NAME);
    return signature;
  }
 catch (  NoSuchAlgorithmException e) {
    throw new IllegalStateException(e);
  }
catch (  InvalidKeyException e) {
    throw new IllegalStateException(e);
  }
catch (  UnsupportedEncodingException shouldntHappen) {
    throw new IllegalStateException(shouldntHappen);
  }
}
 

/** 
 * ???HMAC-SHA1?????????, ?????????,????20???.
 * @param input ????????????
 * @param key   HMAC-SHA1???
 */
public static byte[] hmacSha1(byte[] input,byte[] key){
  try {
    SecretKey secretKey=new SecretKeySpec(key,HMACSHA1);
    Mac mac=Mac.getInstance(HMACSHA1);
    mac.init(secretKey);
    return mac.doFinal(input);
  }
 catch (  GeneralSecurityException e) {
    throw Exceptions.unchecked(e);
  }
}
 

/** 
 * ???HMAC-SHA1?????????, ?????????,????20???.
 * @param input ????????????
 * @param key HMAC-SHA1???
 */
public static byte[] hmacSha1(byte[] input,byte[] key){
  try {
    SecretKey secretKey=new SecretKeySpec(key,HMACSHA1);
    Mac mac=Mac.getInstance(HMACSHA1);
    mac.init(secretKey);
    return mac.doFinal(input);
  }
 catch (  GeneralSecurityException e) {
    throw Exceptions.unchecked(e);
  }
}
 

@Override public void init(Mode mode,byte[] key,byte[] iv){
  key=BaseCipher.resize(key,bsize);
  iv=BaseCipher.resize(iv,ivsize);
  try {
    cipher=SecurityUtils.getCipher(transformation);
    cipher.init((mode == Mode.Encrypt ? javax.crypto.Cipher.ENCRYPT_MODE : javax.crypto.Cipher.DECRYPT_MODE),new SecretKeySpec(key,algorithm),new IvParameterSpec(iv));
  }
 catch (  GeneralSecurityException e) {
    cipher=null;
    throw new SSHRuntimeException(e);
  }
}
 

public String generateMacToken(String method,String uri,String host,String port){
  String ts=String.valueOf(new Date().getTime() / 1000);
  String nonce=String.format("n%d",Math.round(Math.random() * 10000));
  try {
    String baseString=getNormalizedRequestString(ts,nonce,method,uri,host,port);
    Mac mac=Mac.getInstance(SIGNATURE_ALGORITHM);
    SecretKeySpec spec=new SecretKeySpec(oauth2MacKey.getBytes(),SIGNATURE_ALGORITHM);
    try {
      mac.init(spec);
    }
 catch (    InvalidKeyException ike) {
      throw new IllegalStateException(ike);
    }
    byte[] rawMacBytes=mac.doFinal(baseString.getBytes());
    byte[] b64Bytes=Base64.encodeBase64(rawMacBytes);
    String calculatedMac=new String(b64Bytes);
    return String.format("MAC id=\"%s\",ts=\"%s\",nonce=\"%s\",mac=\"%s\"",oauth2Token,ts,nonce,calculatedMac);
  }
 catch (  NoSuchAlgorithmException e) {
    throw new IllegalStateException("This device doesn't have SHA1");
  }
}
 

public MacSyslogMessageModifierConfig(String macAlgorithm,String keyAlgorithm,byte[] keyBytes){
  this.macAlgorithm=macAlgorithm;
  this.keyAlgorithm=keyAlgorithm;
  try {
    this.key=new SecretKeySpec(keyBytes,keyAlgorithm);
  }
 catch (  IllegalArgumentException iae) {
    throw new SyslogRuntimeException(iae);
  }
}
 

/** 
 * Creates a DES encryption key from the given key material.
 * @param bytes A byte array containing the DES key material.
 * @param offset The offset in the given byte array at which the 7-byte key material starts.
 * @return A DES encryption key created from the key material starting atthe specified offset in the given byte array.
 */
private static Key createDESKey(byte[] bytes,int offset){
  byte[] keyBytes=new byte[7];
  System.arraycopy(bytes,offset,keyBytes,0,7);
  byte[] material=new byte[8];
  material[0]=keyBytes[0];
  material[1]=(byte)(keyBytes[0] << 7 | (keyBytes[1] & 0xff) >>> 1);
  material[2]=(byte)(keyBytes[1] << 6 | (keyBytes[2] & 0xff) >>> 2);
  material[3]=(byte)(keyBytes[2] << 5 | (keyBytes[3] & 0xff) >>> 3);
  material[4]=(byte)(keyBytes[3] << 4 | (keyBytes[4] & 0xff) >>> 4);
  material[5]=(byte)(keyBytes[4] << 3 | (keyBytes[5] & 0xff) >>> 5);
  material[6]=(byte)(keyBytes[5] << 2 | (keyBytes[6] & 0xff) >>> 6);
  material[7]=(byte)(keyBytes[6] << 1);
  oddParity(material);
  return new SecretKeySpec(material,"DES");
}
 

@Override public String sign(HttpRequest request,HttpParameters requestParams) throws OAuthMessageSignerException {
  try {
    String keyString=OAuth.percentEncode(getConsumerSecret()) + '&' + OAuth.percentEncode(getTokenSecret());
    byte[] keyBytes=keyString.getBytes(OAuth.ENCODING);
    SecretKey key=new SecretKeySpec(keyBytes,MAC_NAME);
    Mac mac=Mac.getInstance(MAC_NAME);
    mac.init(key);
    String sbs=new SignatureBaseString(request,requestParams).generate();
    OAuth.debugOut("SBS",sbs);
    byte[] text=sbs.getBytes(OAuth.ENCODING);
    return base64Encode(mac.doFinal(text)).trim();
  }
 catch (  GeneralSecurityException e) {
    throw new OAuthMessageSignerException(e);
  }
catch (  UnsupportedEncodingException e) {
    throw new OAuthMessageSignerException(e);
  }
}
 

public AESObfuscator(byte[] salt,String password){
  try {
    SecretKeyFactory factory=SecretKeyFactory.getInstance(KEYGEN_ALGORITHM);
    KeySpec keySpec=new PBEKeySpec(password.toCharArray(),salt,1024,256);
    SecretKey tmp=factory.generateSecret(keySpec);
    SecretKey secret=new SecretKeySpec(tmp.getEncoded(),"AES");
    mEncryptor=Cipher.getInstance(CIPHER_ALGORITHM);
    mEncryptor.init(Cipher.ENCRYPT_MODE,secret,new IvParameterSpec(IV));
    mDecryptor=Cipher.getInstance(CIPHER_ALGORITHM);
    mDecryptor.init(Cipher.DECRYPT_MODE,secret,new IvParameterSpec(IV));
  }
 catch (  GeneralSecurityException e) {
    throw new RuntimeException("Invalid environment",e);
  }
}
 

private byte[] computeSignature(String baseString) throws GeneralSecurityException, UnsupportedEncodingException {
  SecretKey key=null;
synchronized (this) {
    if (this.key == null) {
      String keyString=OAuth.percentEncode(getConsumerSecret()) + '&' + OAuth.percentEncode(getTokenSecret());
      byte[] keyBytes=keyString.getBytes(ENCODING);
      this.key=new SecretKeySpec(keyBytes,MAC_NAME);
    }
    key=this.key;
  }
  Mac mac=Mac.getInstance(MAC_NAME);
  mac.init(key);
  byte[] text=baseString.getBytes(ENCODING);
  return mac.doFinal(text);
}
 

private String authenticate(String channelName){
  if (!isConnected()) {
    Log.e(LOG_TAG,"pusher not connected, can't create auth string");
    return null;
  }
  try {
    String stringToSign=mSocketId + ":" + channelName;
    SecretKey key=new SecretKeySpec(mPusherSecret.getBytes(),PUSHER_AUTH_ALGORITHM);
    Mac mac=Mac.getInstance(PUSHER_AUTH_ALGORITHM);
    mac.init(key);
    byte[] signature=mac.doFinal(stringToSign.getBytes());
    StringBuffer sb=new StringBuffer();
    for (int i=0; i < signature.length; ++i) {
      sb.append(Integer.toHexString((signature[i] >> 4) & 0xf));
      sb.append(Integer.toHexString(signature[i] & 0xf));
    }
    String authInfo=mPusherKey + ":" + sb.toString();
    Log.d(LOG_TAG,"Auth Info " + authInfo);
    return authInfo;
  }
 catch (  NoSuchAlgorithmException e) {
    e.printStackTrace();
  }
catch (  InvalidKeyException e) {
    e.printStackTrace();
  }
  return null;
}
 

/** 
 * @param salt an array of random bytes to use for each (un)obfuscation
 * @param applicationId application identifier, e.g. the package name
 * @param deviceId device identifier. Use as many sources as possible tocreate this unique identifier.
 */
public AESObfuscator(byte[] salt,String applicationId,String deviceId){
  try {
    SecretKeyFactory factory=SecretKeyFactory.getInstance(KEYGEN_ALGORITHM);
    KeySpec keySpec=new PBEKeySpec((applicationId + deviceId).toCharArray(),salt,1024,256);
    SecretKey tmp=factory.generateSecret(keySpec);
    SecretKey secret=new SecretKeySpec(tmp.getEncoded(),"AES");
    mEncryptor=Cipher.getInstance(CIPHER_ALGORITHM);
    mEncryptor.init(Cipher.ENCRYPT_MODE,secret,new IvParameterSpec(IV));
    mDecryptor=Cipher.getInstance(CIPHER_ALGORITHM);
    mDecryptor.init(Cipher.DECRYPT_MODE,secret,new IvParameterSpec(IV));
  }
 catch (  GeneralSecurityException e) {
    throw new RuntimeException("Invalid environment",e);
  }
}
 

/** 
 * Encrypts a text.
 * @param source the plain text to encrypt.
 * @return the encrypted text.
 * @throws Exception
 */
public static String encrypt(final String source,final CryptoAlgorithm algorithm,final String blowfishKey) throws Exception {
  String result="";
  if (CryptoAlgorithm.BLOWFISH.equals(algorithm)) {
    final byte[] keyBytes=new BigInteger(blowfishKey,16).toByteArray();
    final Key key=new SecretKeySpec(keyBytes,"Blowfish");
    final BASE64Encoder encoder=new BASE64Encoder();
    final Cipher cipher=Cipher.getInstance("Blowfish/ECB/PKCS5Padding");
    cipher.init(Cipher.ENCRYPT_MODE,key);
    final byte[] ciphertext=cipher.doFinal(source.getBytes("UTF8"));
    result=encoder.encode(ciphertext);
    return result;
  }
  if (CryptoAlgorithm.DES.equals(algorithm)) {
    result=DES.encrypt(source);
  }
  return result;
}
 

/** 
 * <p> Encrypt a plain text string using AES. The output is an encrypted plain text string. See http://stackoverflow.com/questions/992019/java-256bit-aes-encryption/992413#992413 </p> <p> The algorithm used is <code>base64(aes(plainText))</code> </p>
 * @param plainText text to encrypt
 * @param password password to use for encryption
 * @return encrypted text
 * @throws ChiliLogException
 */
public static String encryptAES(String plainText,String password) throws ChiliLogException {
  try {
    SecretKeyFactory factory=SecretKeyFactory.getInstance("PBKDF2WithHmacSHA1");
    KeySpec spec=new PBEKeySpec(password.toCharArray(),AES_ENCRYPTION_STRING_SALT,1024,128);
    SecretKey tmp=factory.generateSecret(spec);
    SecretKey secret=new SecretKeySpec(tmp.getEncoded(),"AES");
    byte[] plainTextBytes=plainText.getBytes("UTF-8");
    AlgorithmParameterSpec paramSpec=new IvParameterSpec(AES_ENCRYPTION_INTIALIZATION_VECTOR);
    Cipher cipher=Cipher.getInstance("AES/CBC/PKCS5Padding");
    cipher.init(Cipher.ENCRYPT_MODE,secret,paramSpec);
    byte[] cipherText=cipher.doFinal(plainTextBytes);
    Base64 encoder=new Base64(1000,new byte[]{},false);
    return encoder.encodeToString(cipherText);
  }
 catch (  Exception ex) {
    throw new ChiliLogException(ex,"Error attempting to encrypt. " + ex.getMessage());
  }
}
 

private byte[] cipher(byte data[],boolean encrypt) throws NoSuchAlgorithmException, BadPaddingException, IllegalBlockSizeException, InvalidAlgorithmParameterException, InvalidKeyException, NoSuchPaddingException {
  int dir=encrypt ? Cipher.ENCRYPT_MODE : Cipher.DECRYPT_MODE;
  byte[] keyTdesBytes=new byte[24];
  System.arraycopy(kenc,0,keyTdesBytes,0,16);
  System.arraycopy(kenc,0,keyTdesBytes,16,8);
  byte[] ivBytes=new byte[8];
  for (int i=0; i < 8; i++) {
    ivBytes[i]=0x00;
  }
  SecretKey keyTdes=new SecretKeySpec(keyTdesBytes,"DESede");
  Cipher des=Cipher.getInstance("DESede/CBC/NoPadding");
  IvParameterSpec iv=new IvParameterSpec(ivBytes);
  des.init(dir,keyTdes,iv);
  return des.doFinal(data);
}
 

private byte[] computeSignature(String baseString) throws GeneralSecurityException, UnsupportedEncodingException {
  SecretKey key=null;
synchronized (this) {
    if (this.key == null) {
      String keyString=OAuth.percentEncode(getConsumerSecret()) + '&' + OAuth.percentEncode(getTokenSecret());
      byte[] keyBytes=keyString.getBytes(ENCODING);
      this.key=new SecretKeySpec(keyBytes,MAC_NAME);
    }
    key=this.key;
  }
  Mac mac=Mac.getInstance(MAC_NAME);
  mac.init(key);
  byte[] text=baseString.getBytes(ENCODING);
  return mac.doFinal(text);
}
 

private static String encryptUnlockKey(Context context,byte[] salt){
  Cipher encrypter;
  try {
    SecretKeyFactory factory=SecretKeyFactory.getInstance(KEYGEN_ALGORITHM);
    KeySpec keySpec=new PBEKeySpec(getPasswordForDevice(context),salt,1024,256);
    SecretKey tmp=factory.generateSecret(keySpec);
    SecretKey secret=new SecretKeySpec(tmp.getEncoded(),"AES");
    encrypter=Cipher.getInstance(CIPHER_ALGORITHM);
    encrypter.init(Cipher.ENCRYPT_MODE,secret,new IvParameterSpec(AES_IV));
  }
 catch (  GeneralSecurityException e) {
    throw new RuntimeException("Invalid environment",e);
  }
  try {
    return Base64.encodeToString(salt,Base64.NO_WRAP) + Base64.encodeToString(encrypter.doFinal(getUnlockKeyForDevice(context).getBytes("UTF-8")),Base64.NO_WRAP);
  }
 catch (  IllegalBlockSizeException e) {
    throw new RuntimeException("Encoding error",e);
  }
catch (  BadPaddingException e) {
    throw new RuntimeException("Encoding error",e);
  }
catch (  UnsupportedEncodingException e) {
    throw new RuntimeException("Invalid environment",e);
  }
}
 

/** 
 * Creates a DES encryption key from the given key material.
 * @param bytes A byte array containing the DES key material.
 * @param offset The offset in the given byte array at which the 7-byte key material starts.
 * @return A DES encryption key created from the key material starting atthe specified offset in the given byte array.
 */
private static Key createDESKey(byte[] bytes,int offset){
  byte[] keyBytes=new byte[7];
  System.arraycopy(bytes,offset,keyBytes,0,7);
  byte[] material=new byte[8];
  material[0]=keyBytes[0];
  material[1]=(byte)(keyBytes[0] << 7 | (keyBytes[1] & 0xff) >>> 1);
  material[2]=(byte)(keyBytes[1] << 6 | (keyBytes[2] & 0xff) >>> 2);
  material[3]=(byte)(keyBytes[2] << 5 | (keyBytes[3] & 0xff) >>> 3);
  material[4]=(byte)(keyBytes[3] << 4 | (keyBytes[4] & 0xff) >>> 4);
  material[5]=(byte)(keyBytes[4] << 3 | (keyBytes[5] & 0xff) >>> 5);
  material[6]=(byte)(keyBytes[5] << 2 | (keyBytes[6] & 0xff) >>> 6);
  material[7]=(byte)(keyBytes[6] << 1);
  oddParity(material);
  return new SecretKeySpec(material,"DES");
}
 

private byte[] computeSignature(String baseString) throws GeneralSecurityException, UnsupportedEncodingException {
  SecretKey key=null;
synchronized (this) {
    if (this.key == null) {
      String keyString=OAuth.percentEncode(getConsumerSecret()) + '&' + OAuth.percentEncode(getTokenSecret());
      byte[] keyBytes=keyString.getBytes(ENCODING);
      this.key=new SecretKeySpec(keyBytes,MAC_NAME);
    }
    key=this.key;
  }
  Mac mac=Mac.getInstance(MAC_NAME);
  mac.init(key);
  byte[] text=baseString.getBytes(ENCODING);
  return mac.doFinal(text);
}
 

public RaopServer(RaopSession session){
  super("RaopServer " + session.getId());
  this.port=session.getControlPort() - 1;
  this.session=session;
  try {
    this.aesCipher=Cipher.getInstance("AES/CBC/NOPADDING");
    receiveSocket=new DatagramSocket(port);
    DataLine.Info info=new DataLine.Info(SourceDataLine.class,new AudioFormat(session.getFormat().getSampleRate(),session.getFormat().getSampleSize(),2,true,true));
    line=(SourceDataLine)AudioSystem.getLine(info);
    line.open();
    line.start();
  }
 catch (  Exception e) {
    throw new RuntimeException(e);
  }
  secretKey=new SecretKeySpec(session.getAesKey(),"AES");
  secretKey=new SecretKeySpec(session.getAesKey(),"AES");
  keySpec=new IvParameterSpec(session.getAesIv());
  int frameSize=session.getFormat().getFrameSize();
  alac=AlacDecodeUtils.create_alac(session.getFormat().getSampleSize(),2);
  alac.setSetinfo_max_samples_per_frame(frameSize);
  alac.setSetinfo_rice_historymult(session.getFormat().getRiceHistoryMult());
  alac.setSetinfo_rice_initialhistory(session.getFormat().getRiceInitialHistory());
  alac.setSetinfo_rice_kmodifier(session.getFormat().getRiceKModifier());
  alac.setSetinfo_sample_size(session.getFormat().getSampleSize());
  outbuffer=new int[frameSize * 4];
  outbufferBytes=new byte[outbuffer.length * 2];
}
 

private String generateSignature(String baseUrl,SortedMap<String,String> args) throws UnsupportedEncodingException, InvalidKeyException, NoSuchAlgorithmException {
  String encoding="UTF-8";
  baseUrl=URLEncoder.encode(baseUrl,encoding);
  StringBuilder sb=new StringBuilder();
  boolean isFirst=true;
  for (  Map.Entry<String,String> arg : args.entrySet()) {
    if (isFirst) {
      isFirst=false;
    }
 else {
      sb.append('&');
    }
    sb.append(URLEncoder.encode(arg.getKey(),encoding));
    sb.append('=');
    sb.append(URLEncoder.encode(arg.getValue(),encoding));
  }
  String parameters=URLEncoder.encode(sb.toString(),encoding);
  String signatureBaseString="GET&" + baseUrl + "&"+ parameters;
  String key=(consumerSecret != null ? consumerSecret : "") + "&" + (userSecret != null ? userSecret : "");
  String macName="HmacSHA1";
  Mac mac=Mac.getInstance(macName);
  mac.init(new SecretKeySpec(key.getBytes(encoding),macName));
  byte[] signature=mac.doFinal(signatureBaseString.getBytes(encoding));
  return new Base64().encodeToString(signature).trim();
}
 

/** 
 * Generates MAC to be appended onto out-going messages.
 * @param Ki A non-null byte array containing the key for the digest
 * @param seqnum A non-null byte array contain the sequence number
 * @param msg  The message to be digested
 * @param start The offset from which to read the msg byte array
 * @param len The non-zero number of bytes to be read from the offset
 * @return The MAC of a message.
 * @throws javax.security.sasl.SaslException if an error occurs when generating MAC.
 */
protected byte[] getHMAC(byte[] Ki,byte[] seqnum,byte[] msg,int start,int len) throws SaslException {
  byte[] seqAndMsg=new byte[4 + len];
  System.arraycopy(seqnum,0,seqAndMsg,0,4);
  System.arraycopy(msg,start,seqAndMsg,4,len);
  try {
    SecretKey keyKi=new SecretKeySpec(Ki,"HmacMD5");
    Mac m=Mac.getInstance("HmacMD5");
    m.init(keyKi);
    m.update(seqAndMsg);
    byte[] hMAC_MD5=m.doFinal();
    byte macBuffer[]=new byte[10];
    System.arraycopy(hMAC_MD5,0,macBuffer,0,10);
    return macBuffer;
  }
 catch (  InvalidKeyException e) {
    throw new SaslException("DIGEST-MD5: Invalid bytes used for " + "key of HMAC-MD5 hash.",e);
  }
catch (  NoSuchAlgorithmException e) {
    throw new SaslException("DIGEST-MD5: Error creating " + "instance of MD5 digest algorithm",e);
  }
}
 

/** 
 * Create a new S3 client for the supplied user information. <p> The connection properties are a subset of those supported by the popular <a href="http://jets3t.s3.amazonaws.com/index.html">jets3t</a> library. For example: <pre> # AWS Access and Secret Keys (required) accesskey: &lt;YourAWSAccessKey&gt; secretkey: &lt;YourAWSSecretKey&gt; # Access Control List setting to apply to uploads, must be one of: # PRIVATE, PUBLIC_READ (defaults to PRIVATE). acl: PRIVATE # Number of times to retry after internal error from S3. httpclient.retry-max: 3 # End-to-end encryption (hides content from S3 owners) password: &lt;encryption pass-phrase&gt; crypto.algorithm: PBEWithMD5AndDES </pre>
 * @param props connection properties.
 */
public AmazonS3(final Properties props){
  publicKey=props.getProperty("accesskey");
  if (publicKey == null)   throw new IllegalArgumentException("Missing accesskey.");
  final String secret=props.getProperty("secretkey");
  if (secret == null)   throw new IllegalArgumentException("Missing secretkey.");
  privateKey=new SecretKeySpec(Constants.encodeASCII(secret),HMAC);
  final String pacl=props.getProperty("acl","PRIVATE");
  if ("PRIVATE".equalsIgnoreCase(pacl))   acl="private";
 else   if ("PUBLIC".equalsIgnoreCase(pacl))   acl="public-read";
 else   if ("PUBLIC-READ".equalsIgnoreCase(pacl))   acl="public-read";
 else   if ("PUBLIC_READ".equalsIgnoreCase(pacl))   acl="public-read";
 else   throw new IllegalArgumentException("Invalid acl: " + pacl);
  try {
    final String cPas=props.getProperty("password");
    if (cPas != null) {
      String cAlg=props.getProperty("crypto.algorithm");
      if (cAlg == null)       cAlg="PBEWithMD5AndDES";
      encryption=new WalkEncryption.ObjectEncryptionV2(cAlg,cPas);
    }
 else {
      encryption=WalkEncryption.NONE;
    }
  }
 catch (  InvalidKeySpecException e) {
    throw new IllegalArgumentException("Invalid encryption",e);
  }
catch (  NoSuchAlgorithmException e) {
    throw new IllegalArgumentException("Invalid encryption",e);
  }
  maxAttempts=Integer.parseInt(props.getProperty("httpclient.retry-max","3"));
  proxySelector=ProxySelector.getDefault();
}
 

private Mac getMac(String consumerSecret){
  try {
    SecretKey key=new SecretKeySpec((consumerSecret + '&').getBytes(UTF_8),MAC_NAME);
    Mac result=Mac.getInstance(MAC_NAME);
    result.init(key);
    return result;
  }
 catch (  UnsupportedEncodingException e) {
    log.log(Level.SEVERE,"This exception should never ocurr!",e);
  }
catch (  NoSuchAlgorithmException e) {
    log.log(Level.SEVERE,"This exception should never ocurr!",e);
  }
catch (  InvalidKeyException e) {
    log.log(Level.SEVERE,"The key used to initialize MAC algorithm is invalid.",e);
  }
  return null;
}
 

public JreepadTreeModel read(InputStream in) throws IOException {
  while (in.read() != '\n')   ;
  Cipher cipher=null;
  try {
    cipher=Cipher.getInstance(EncryptedWriter.ALGORITHM);
    Key key=new SecretKeySpec(password.getBytes(),EncryptedWriter.ALGORITHM);
    cipher.init(Cipher.DECRYPT_MODE,key);
  }
 catch (  GeneralSecurityException e) {
    throw new IOException(e.toString());
  }
  InputStream in2=new CipherInputStream(in,cipher);
  JreepadTreeModel document;
  try {
    document=reader.read(in2);
  }
 catch (  IOException e) {
    throw new IOException("Password incorrect or read problem occurred");
  }
  document.setFileType(JreepadPrefs.FILETYPE_XML_ENCRYPTED);
  document.setPassword(password);
  return document;
}
 

/** 
 * @param salt an array of random bytes to use for each (un)obfuscation
 * @param applicationId application identifier, e.g. the package name
 * @param deviceId device identifier. Use as many sources as possible to create this unique identifier.
 */
public AESObfuscator(byte[] salt,String applicationId,String deviceId){
  try {
    SecretKeyFactory factory=SecretKeyFactory.getInstance(KEYGEN_ALGORITHM);
    KeySpec keySpec=new PBEKeySpec((applicationId + deviceId).toCharArray(),salt,1024,256);
    SecretKey tmp=factory.generateSecret(keySpec);
    SecretKey secret=new SecretKeySpec(tmp.getEncoded(),"AES");
    mEncryptor=Cipher.getInstance(CIPHER_ALGORITHM);
    mEncryptor.init(Cipher.ENCRYPT_MODE,secret,new IvParameterSpec(IV));
    mDecryptor=Cipher.getInstance(CIPHER_ALGORITHM);
    mDecryptor.init(Cipher.DECRYPT_MODE,secret,new IvParameterSpec(IV));
  }
 catch (  GeneralSecurityException e) {
    throw new RuntimeException("Invalid environment",e);
  }
}
 

private static String calculateMAC(String key,String normalizedString,String algorithm){
  String macString="";
  try {
    System.out.println("algorithm=" + algorithm);
    Mac mac=Mac.getInstance(algorithm);
    mac.init(new SecretKeySpec(key.getBytes(),algorithm));
    macString=Base64.encodeToString(mac.doFinal(normalizedString.getBytes()),Base64.DEFAULT);
  }
 catch (  InvalidKeyException ex) {
    Logger.getLogger(MacTokenTypeDefinition.class.getName()).log(Level.SEVERE,null,ex);
  }
catch (  NoSuchAlgorithmException ex) {
    Logger.getLogger(MacTokenTypeDefinition.class.getName()).log(Level.SEVERE,null,ex);
  }
  return macString;
}
 

/** 
 * Encrypt or decrypt the given data using the given key using the given cipher.
 * @param data                 The data to decrypt.
 * @param key                  The encryption key to decrypt the data with.
 * @param cipherTransformation The cipher to use for performing the operation.
 * @param blockBitSize         The bit-length of the blocks the cipher should operate on.  The key will be trimmed to this size.
 * @param mode                 {@code Cipher.ENCRYPT_MODE}  or {@code Cipher.DECRYPT_MODE}
 * @return The decrypted version of the encrypted data as decrypted by the given key.
 * @throws IllegalBlockSizeException While encrypting without padding, the plain text data's length is not a multiple of the cipherblock size.
 * @throws BadPaddingException       While decrypting with padding, the encrypted data was not padded during encryption.
 */
public static byte[] doCrypt(final byte[] data,final byte[] key,final String cipherTransformation,final int blockBitSize,final int mode) throws IllegalBlockSizeException, BadPaddingException {
  int blockByteSize=blockBitSize / Byte.SIZE;
  byte[] blockSizedKey=key;
  if (blockSizedKey.length != blockByteSize) {
    blockSizedKey=new byte[blockByteSize];
    System.arraycopy(key,0,blockSizedKey,0,blockByteSize);
  }
  try {
    Cipher cipher=Cipher.getInstance(cipherTransformation);
    cipher.init(mode,new SecretKeySpec(blockSizedKey,"AES"));
    return cipher.doFinal(data);
  }
 catch (  NoSuchAlgorithmException e) {
    throw new IllegalStateException("Cipher transformation: " + cipherTransformation + ", is not valid or not supported by the provider.",e);
  }
catch (  NoSuchPaddingException e) {
    throw new IllegalStateException("Cipher transformation: " + cipherTransformation + ", uses a padding scheme that is not valid or not supported by the provider.",e);
  }
catch (  InvalidKeyException e) {
    throw logger.bug(e,"Key is inappropriate for cipher.");
  }
}
 

@Override public byte[] decryptCipherText(Jwe jwe,byte[] contentEncryptionKey) throws NoSuchAlgorithmException, NoSuchPaddingException, InvalidKeyException, IllegalBlockSizeException, BadPaddingException, InvalidAlgorithmParameterException {
  byte[] iv=new byte[16];
  iv=Base64.decodeBase64(jwe.getHeader().getInitializationVector());
  String encMethod=jwe.getHeader().getEncryptionMethod();
  if (encMethod.equals("A128CBC") || encMethod.equals("A256CBC")) {
    String mode=JweAlgorithms.getByName(encMethod);
    Cipher cipher=Cipher.getInstance("AES/" + mode + "/PKCS5Padding");
    cipher.init(Cipher.DECRYPT_MODE,new SecretKeySpec(contentEncryptionKey,"AES"),new IvParameterSpec(iv));
    byte[] clearText=cipher.doFinal(jwe.getCiphertext());
    return clearText;
  }
 else {
    throw new IllegalArgumentException(jwe.getHeader().getEncryptionMethod() + " is not an implemented encryption method");
  }
}
 

private byte[] computeSignature(String baseString) throws GeneralSecurityException, UnsupportedEncodingException {
  SecretKey key=null;
synchronized (this) {
    if (this.key == null) {
      String keyString=OAuth.percentEncode(getConsumerSecret()) + '&' + OAuth.percentEncode(getTokenSecret());
      byte[] keyBytes=keyString.getBytes(ENCODING);
      this.key=new SecretKeySpec(keyBytes,MAC_NAME);
    }
    key=this.key;
  }
  Mac mac=Mac.getInstance(MAC_NAME);
  mac.init(key);
  byte[] text=baseString.getBytes(ENCODING);
  return mac.doFinal(text);
}
 

/** 
 * Compute signature.
 * @param baseString the base string
 * @return the byte[]
 * @throws GeneralSecurityException the general security exception
 * @throws UnsupportedEncodingException the unsupported encoding exception
 */
private byte[] computeSignature(String baseString) throws GeneralSecurityException, UnsupportedEncodingException {
  SecretKey key=null;
synchronized (this) {
    if (this.key == null) {
      String keyString=OAuth.percentEncode(getConsumerSecret()) + '&' + OAuth.percentEncode(getTokenSecret());
      byte[] keyBytes=keyString.getBytes(ENCODING);
      this.key=new SecretKeySpec(keyBytes,MAC_NAME);
    }
    key=this.key;
  }
  Mac mac=Mac.getInstance(MAC_NAME);
  mac.init(key);
  byte[] text=baseString.getBytes(ENCODING);
  return mac.doFinal(text);
}
 

@Override public String sign(HttpRequest request,HttpParameters requestParams) throws OAuthMessageSignerException {
  try {
    String keyString=OAuth.percentEncode(getConsumerSecret()) + '&' + OAuth.percentEncode(getTokenSecret());
    byte[] keyBytes=keyString.getBytes(OAuth.ENCODING);
    SecretKey key=new SecretKeySpec(keyBytes,MAC_NAME);
    Mac mac=Mac.getInstance(MAC_NAME);
    mac.init(key);
    String sbs=new SignatureBaseString(request,requestParams).generate();
    OAuth.debugOut("SBS",sbs);
    byte[] text=sbs.getBytes(OAuth.ENCODING);
    return base64Encode(mac.doFinal(text)).trim();
  }
 catch (  GeneralSecurityException e) {
    throw new OAuthMessageSignerException(e);
  }
catch (  UnsupportedEncodingException e) {
    throw new OAuthMessageSignerException(e);
  }
}
 

/** 
 * bit must be dividable by 8.
 * @param password
 * @param bit
 */
public void init() throws ConfigException {
  try {
    this.key=new byte[keylength / 8];
    MessageDigest msgDigest=MessageDigest.getInstance("SHA-256");
    msgDigest.reset();
    byte[] longkey=msgDigest.digest(password.getBytes("UTF-8"));
    if (longkey.length == key.length) {
      this.key=longkey;
    }
 else     if (longkey.length > key.length) {
      System.arraycopy(longkey,0,key,0,key.length);
    }
 else     if (longkey.length < key.length) {
      throw new RuntimeException("Invalid key length '" + keylength + "' bit; max 256 bit supported.");
    }
    this.keySpec=new SecretKeySpec(key,cipherStr);
    this.cipher=Cipher.getInstance(cipherStr);
    byte[] testBytes=new byte[]{1,2,3,4,5,6,7,8,9,1,2,3,4,5,6,7,8,9};
    if (!Arrays.equals(decrypt(encrypt(testBytes)),testBytes)) {
      throw new ConfigException("Test encrypt/decrypt cycle failed.");
    }
  }
 catch (  Exception e) {
    throw new ConfigException("Invalid encryption parameters.",e);
  }
}
 

/** 
 * Creates a DES encryption key from the given key material.
 * @param bytes A byte array containing the DES key material.
 * @param offset The offset in the given byte array at whichthe 7-byte key material starts.
 * @return A DES encryption key created from the key materialstarting at the specified offset in the given byte array.
 */
private static Key createDESKey(byte[] bytes,int offset){
  byte[] keyBytes=new byte[7];
  System.arraycopy(bytes,offset,keyBytes,0,7);
  byte[] material=new byte[8];
  material[0]=keyBytes[0];
  material[1]=(byte)(keyBytes[0] << 7 | (keyBytes[1] & 0xff) >>> 1);
  material[2]=(byte)(keyBytes[1] << 6 | (keyBytes[2] & 0xff) >>> 2);
  material[3]=(byte)(keyBytes[2] << 5 | (keyBytes[3] & 0xff) >>> 3);
  material[4]=(byte)(keyBytes[3] << 4 | (keyBytes[4] & 0xff) >>> 4);
  material[5]=(byte)(keyBytes[4] << 3 | (keyBytes[5] & 0xff) >>> 5);
  material[6]=(byte)(keyBytes[5] << 2 | (keyBytes[6] & 0xff) >>> 6);
  material[7]=(byte)(keyBytes[6] << 1);
  oddParity(material);
  return new SecretKeySpec(material,"DES");
}
 

public EncryptionManager(String encryptionScheme,String encryptionKey) throws ThinklabValidationException {
  if (encryptionKey == null)   throw new IllegalArgumentException("encryption key was null");
  if (encryptionKey.trim().length() < 24)   throw new IllegalArgumentException("encryption key was less than 24 characters");
  try {
    byte[] keyAsBytes=encryptionKey.getBytes(UNICODE_FORMAT);
    if (encryptionScheme.equals(DESEDE_ENCRYPTION_SCHEME)) {
      keySpec=new DESedeKeySpec(keyAsBytes);
    }
 else     if (encryptionScheme.equals(DES_ENCRYPTION_SCHEME)) {
      keySpec=new DESKeySpec(keyAsBytes);
    }
 else {
      keySpec=new SecretKeySpec(keyAsBytes,encryptionKey);
    }
    keyFactory=SecretKeyFactory.getInstance(encryptionScheme);
    cipher=Cipher.getInstance(encryptionScheme);
  }
 catch (  InvalidKeyException e) {
    throw new ThinklabValidationException(e);
  }
catch (  UnsupportedEncodingException e) {
    throw new ThinklabValidationException(e);
  }
catch (  NoSuchAlgorithmException e) {
    throw new ThinklabValidationException(e);
  }
catch (  NoSuchPaddingException e) {
    throw new ThinklabValidationException(e);
  }
}
 

public CipherStorageOutputStream(StorageOutputStream out,String algorithm,SecretKeySpec skeySpec) throws IOException {
  try {
    this.storageOut=out;
    this.algorithm=algorithm;
    this.skeySpec=skeySpec;
    Cipher cipher=Cipher.getInstance(algorithm);
    cipher.init(Cipher.ENCRYPT_MODE,skeySpec);
    this.cipherOut=new CipherOutputStream(out,cipher);
  }
 catch (  GeneralSecurityException e) {
    throw (IOException)new IOException().initCause(e);
  }
}
 

public CipherStorageOutputStream(StorageOutputStream out,String algorithm,SecretKeySpec skeySpec) throws IOException {
  try {
    this.storageOut=out;
    this.algorithm=algorithm;
    this.skeySpec=skeySpec;
    Cipher cipher=Cipher.getInstance(algorithm);
    cipher.init(Cipher.ENCRYPT_MODE,skeySpec);
    this.cipherOut=new CipherOutputStream(out,cipher);
  }
 catch (  GeneralSecurityException e) {
    throw (IOException)new IOException().initCause(e);
  }
}