org.apache.fulcrum.jce.crypto.CryptoStreamFactoryImpl Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of fulcrum-yaafi-crypto Show documentation
Fulcrum YAAFI Crypto Library
The newest version!
package org.apache.fulcrum.jce.crypto;

/*
 * Licensed to the Apache Software Foundation (ASF) under one
 * or more contributor license agreements.  See the NOTICE file
 * distributed with this work for additional information
 * regarding copyright ownership.  The ASF licenses this file
 * to you under the Apache License, Version 2.0 (the
 * "License"); you may not use this file except in compliance
 * with the License.  You may obtain a copy of the License at
 *
 *   http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing,
 * software distributed under the License is distributed on an
 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
 * KIND, either express or implied.  See the License for the
 * specific language governing permissions and limitations
 * under the License.
 */

import java.io.IOException;
import java.io.InputStream;
import java.security.GeneralSecurityException;
import java.security.Key;

import javax.crypto.Cipher;
import javax.crypto.SecretKeyFactory;
import javax.crypto.spec.PBEKeySpec;
import javax.crypto.spec.PBEParameterSpec;

/**
 * Concrete factory for creating encrypting/decrypting streams. The
 * implementation uses the JCA (Java Crypto Extension) supplied
 * by SUN (using SunJCE 1.42).
 *
 * The implementation uses as PBEWithMD5AndDES for encryption which
 * should be sufficent for most applications.
 *
 * The implementation also supplies a default password in the case that
 * the programmer don't want to have additional hassles. It is easy to
 * reengineer the password being used but much better than a hard-coded
 * password in the application.
 *
 * The code uses parts from Markus Hahn's Blowfish library found at
 * http://blowfishj.sourceforge.net/
 *
 * @author Siegfried Goeschl 
 * @author Markus Hahn
 */

public class CryptoStreamFactoryImpl extends CryptoStreamFactoryTemplate implements CryptoStreamFactory
{
    /** the salt for the PBE algorithm */
    protected final byte[] salt;

    /** the count paramter for the PBE algorithm */
    protected int count;

    /** the name of the JCE provider */
    protected String providerName;

    /** the algorithm to use */
    protected String algorithm;

    /** the default instance */
    private static CryptoStreamFactory instance;

    /**
     * The JCE provider name known to work. If the value
     * is set to null an appropriate provider will be
     * used.
     */
    protected static final String PROVIDERNAME = null;

    /**
     * Factory method to get a default instance
     * @return an instance of the CryptoStreamFactory
     */
    public static CryptoStreamFactory getInstance()
    {
        synchronized(CryptoStreamFactoryImpl.class ) {
            if( CryptoStreamFactoryImpl.instance == null )
            {
                CryptoStreamFactoryImpl.instance = new CryptoStreamFactoryImpl();
            }
    
            return CryptoStreamFactoryImpl.instance;
        }
    }

    /**
     * Set the default instance from an external application.
     * @param instance the new default instance
     */
    public static void setInstance( CryptoStreamFactory instance )
    {
        CryptoStreamFactoryImpl.instance = instance;
    }

    /**
     * Constructor
     */
    public CryptoStreamFactoryImpl()
    {
        this.salt = CryptoParameters.Salt();
        this.count = CryptoParameters.COUNT;
        this.providerName = PROVIDERNAME;
        this.algorithm = CryptoParameters.ALGORITHM;
    }

    /**
     * Constructor
     *
     * @param salt the salt for the PBE algorithm
     * @param count the iteration for PBEParameterSpec
     */
    public CryptoStreamFactoryImpl( byte[] salt, int count)
    {
        this.salt = salt.clone();
        this.count = count;
        this.providerName = PROVIDERNAME;
        this.algorithm = CryptoParameters.ALGORITHM;
    }
    

    /**
     * Factory method to get a default instance
     * 
     * @param salt the salt for the PBE algorithm
     * @param count the iteration for PBEParameterSpec
     * @return an instance of the CryptoStreamFactory
     * 
     */
    public static CryptoStreamFactory getInstance( byte[] salt, int count)
    {
        synchronized(CryptoStreamFactoryImpl.class ) {
            if( CryptoStreamFactoryImpl.instance == null )
            {
                CryptoStreamFactoryImpl.instance = new CryptoStreamFactoryImpl(salt, count);
            }
    
            return CryptoStreamFactoryImpl.instance;
        }
    }

    /**
     * @see org.apache.fulcrum.jce.crypto.CryptoStreamFactory#getSmartInputStream(java.io.InputStream,char[])
     * 
     * 
     */
    public InputStream getSmartInputStream(InputStream is, char[] password )
        throws GeneralSecurityException, IOException
    {
        SmartDecryptingInputStream result;

        result = new SmartDecryptingInputStream(
            getInstance(),
            is,
            password
            );

        return result;
    }

    /**
     * @return Returns the algorithm.
     */
    @Override
    public String getAlgorithm()
    {
        return algorithm;
    }

    /**
     * @return Returns the count.
     */
    protected int getCount()
    {
        return count;
    }

    /**
     * @return Returns the providerName.
     */
    protected String getProviderName()
    {
        return providerName;
    }

    /**
     * @return Returns the salt.
     */
    protected byte [] getSalt()
    {
        return salt;
    }

    /**
     * Create a PBE key.
     *
     * @param password the password to use.
     * @return the key
     * @throws GeneralSecurityException creating the key failed
     */
    protected Key createKey( char[] password )
        throws GeneralSecurityException
    {
        SecretKeyFactory keyFactory;
        String algorithm = this.getAlgorithm();
        PBEKeySpec keySpec =  new PBEKeySpec(password);

        if( this.getProviderName() == null )
        {
            keyFactory = SecretKeyFactory.getInstance( algorithm );
        }
        else
        {
            keyFactory = SecretKeyFactory.getInstance( algorithm, this.getProviderName() );
        }

        return keyFactory.generateSecret(keySpec);
    }

    /**
     * Create a Cipher.
     *
     * @param mode the cipher mode
     * @param password the password
     * @return an instance of a cipher
     * @throws GeneralSecurityException creating a cipher failed
     * @throws IOException creating a cipher failed
     */
    protected Cipher createCipher( int mode, char[] password )
        throws GeneralSecurityException, IOException
    {
        Cipher cipher;
        PBEParameterSpec paramSpec = new PBEParameterSpec( this.getSalt(), this.getCount() );
        Key key = this.createKey( password );

        if( this.getProviderName() == null )
        {
            cipher = Cipher.getInstance( this.getAlgorithm() );
        }
        else
        {
            cipher = Cipher.getInstance( this.getAlgorithm(), this.getProviderName() );
        }

        cipher.init( mode, key, paramSpec );
        return cipher;
    }
}