Logo
Distributed Genetic Programming Framework
print print

File org.sfc.crypt.CryptographicAlgorithm.java

Here you can find all the information about the file org.sfc.crypt.CryptographicAlgorithm.java. You may explore it here or download it onto your local disk.
/*
 * Copyright (c) 2006 Thomas Weise
 * 
 * E-Mail           : tweise@gmx.de
 * Creation Date    : 2006-06-30 06:35:14
 * Original Filename: org.sfc.crypt.CryptographicAlgorithm.java
 * Version          : 1.0.0
 * Last modification: 2006-06-30
 *                by: Thomas Weise
 * 
 * License          : GNU LESSER GENERAL PUBLIC LICENSE
 *                    Version 2.1, February 1999
 *                    You should have received a copy of this license along
 *                    with this library; if not, write to the Free Software
 *                    Foundation, Inc., 59 Temple Place, Suite 330, Boston,
 *                    MA 02111-1307, USA or download the license under
 *                    http://www.gnu.org/copyleft/lesser.html.
 *                    
 * Warranty         : This software is provided "as is" without any
 *                    warranty; without even the implied warranty of
 *                    merchantability or fitness for a particular purpose.
 *                    See the Gnu Lesser General Public License for more
 *                    details.
 */

 
package org.sfc.crypt;


/**
 * This is the abstract base class for crypto algorithms.
 *
 * @author Thomas Weise
 */

public abstract class CryptographicAlgorithm  extends CryptographicKey
  {
/**
 * The next algorithm in the chain. 
 */

  final CryptographicAlgorithm  m_next    ;
  
/**
 * Create a new cryptographic algorithm instance.
 * @param p_next    The next algorithm to be executed after this one.
 * @param p_key     The cryptographic key to be used.
 */

  protected CryptographicAlgorithm  (final CryptographicAlgorithm p_next,
                                     final CryptographicKey       p_key)
    {
    super(p_key);    
    this.m_next   = p_next;
    }
  
/**
 * This method is called to encrypt a block of bytes (plain text).
 * @param p_data    The data bytes to be encrypted.
 * @param p_key     The key to be used for encryption.
 */

  protected abstract  void  encrypt (final byte[]     p_data,
                                     final byte[]     p_key);
  
/**
 * This method is called to decrypt a encrypted block of bytes (cipher
 * text).
 * @param p_data    The (encrypted) data bytes to be decrypted.
 * @param p_key     The key to be used for decryption.
 */

  protected abstract  void  decrypt (final byte[]     p_data,
                                     final byte[]     p_key);
  
/**
 * Obtain a human readable name of this crypt algorithm.
 * @return A human readable name of this crypt algorithm.
 */

  @Override
  public    abstract  String  toString();
  
/**
 * Obtain a byte from a byte array. This method wraps the index if it is
 * out of bounds.
 * @param p_bytes   The byte array to extract a byte from.
 * @param p_index   The byte index of the wanted byte.
 * @return  The byte wanted.
 */

  protected static  final byte  get_byte  (final byte[] p_bytes,
                                                 int    p_index)
    {
    int l_i;
    l_i = p_bytes.length;
    p_index %= l_i;
    if(p_index >= 0) return p_bytes[p_index];
    return p_bytes[p_index + l_i];
    }
  
/**
 * Write a byte to a byte array. This method wraps the index if it is
 * out of bounds.
 * @param p_bytes   The byte array to write the byte to.
 * @param p_index   The byte index of the byte to be written.
 * @param p_byte    The byte to be written.
 */

  protected static  final void  set_byte  (final byte[] p_bytes,
                                                 int    p_index,
                                           final byte   p_byte)
    {
    int l_i;
    l_i = p_bytes.length;
    p_index %= l_i;
    if(p_index >= 0) p_bytes[p_index]       = p_byte;
    else             p_bytes[p_index + l_i] = p_byte;
    }
  
/**
 * Obtain a short from a byte array. This method wraps the index if it is
 * out of bounds.
 * @param p_bytes   The byte array to extract a short from.
 * @param p_index   The byte index of the wanted short.
 * @return  The short wanted.
 */

  protected static  final short get_short (final byte[] p_bytes,
                                                 int    p_index)
    {
    return (short)(((get_byte(p_bytes, p_index)   & 0xff) << 8) +
                    (get_byte(p_bytes, p_index+1) & 0xff));
    }
  
/**
 * Write a short to a byte array. This method wraps the index if it is
 * out of bounds.
 * @param p_bytes   The byte array to write the short to.
 * @param p_index   The byte index of the short to be written.
 * @param p_short   The short to be written.
 */

  protected static  final void  set_short  (final byte[] p_bytes,
                                                  int    p_index,
                                            final short  p_short)
    {
    set_byte(p_bytes, p_index, (byte)(p_short >>> 8));
    set_byte(p_bytes, p_index+1, (byte)(p_short & 0xff));
    }
  
/**
 * Obtain an int from a byte array. This method wraps the index if it is
 * out of bounds.
 * @param p_bytes   The byte array to extract an int from.
 * @param p_index   The byte index of the wanted int.
 * @return  The int wanted.
 */

  protected static  final int get_int (final byte[] p_bytes,
                                             int    p_index)
    {
    return (((get_byte(p_bytes, p_index++) & 0xff) <<  8) +
            ((get_byte(p_bytes, p_index++) & 0xff) << 16) +
            ((get_byte(p_bytes, p_index++) & 0xff) << 24) +
             (get_byte(p_bytes, p_index)   & 0xff));
    }
  
/**
 * Write an int to a byte array. This method wraps the index if it is
 * out of bounds.
 * @param p_bytes   The byte array to write the int to.
 * @param p_index   The byte index of the int to be written.
 * @param p_int     The int to be written.
 */

  protected static  final void  set_int  (final byte[] p_bytes,
                                                int    p_index,
                                          final int    p_int)
    {
    set_byte(p_bytes, p_index++, (byte)((p_int >>>  8) & 0xff));
    set_byte(p_bytes, p_index++, (byte)((p_int >>> 16) & 0xff));
    set_byte(p_bytes, p_index++, (byte)((p_int >>> 24) & 0xff));
    set_byte(p_bytes, p_index,   (byte)(p_int & 0xff));
    }
  
/**
 * Obtain a long from a byte array. This method wraps the index if it is
 * out of bounds.
 * @param p_bytes   The byte array to extract a long from.
 * @param p_index   The byte index of the wanted long.
 * @return  The long wanted.
 */

  protected static  final long get_long (final byte[] p_bytes,
                                               int    p_index)
    {
    return (((long)(get_byte(p_bytes, p_index++) & 0xff) << 40) +
            ((long)(get_byte(p_bytes, p_index++) & 0xff) << 24) +
            ((long)(get_byte(p_bytes, p_index++) & 0xff) << 56) +
            (      (get_byte(p_bytes, p_index++) & 0xff) <<  8) +
            ((long)(get_byte(p_bytes, p_index++) & 0xff) << 48) +
            (      (get_byte(p_bytes, p_index++) & 0xff)      ) +
            ((long)(get_byte(p_bytes, p_index++) & 0xff) << 32) +
            (      (get_byte(p_bytes, p_index)   & 0xff) << 16));
    }
  
/**
 * Write a long to a byte array. This method wraps the index if it is
 * out of bounds.
 * @param p_bytes   The byte array to write the long to.
 * @param p_index   The byte index of the long to be written.
 * @param p_long    The long to be written.
 */

  protected static  final void  set_long (final byte[] p_bytes,
                                                int    p_index,
                                          final long   p_long)
    {
    set_byte(p_bytes, p_index++, (byte)((p_long >>> 40) & 0xff));
    set_byte(p_bytes, p_index++, (byte)((p_long >>> 24) & 0xff));
    set_byte(p_bytes, p_index++, (byte)((p_long >>> 56) & 0xff));
    set_byte(p_bytes, p_index++, (byte)((p_long >>>  8) & 0xff));
    set_byte(p_bytes, p_index++, (byte)((p_long >>> 48) & 0xff));
    set_byte(p_bytes, p_index++, (byte)((p_long       ) & 0xff));
    set_byte(p_bytes, p_index++, (byte)((p_long >>> 32) & 0xff));
    set_byte(p_bytes, p_index,   (byte)((p_long >>> 16) & 0xff));
    }
  
  

/**
 * Obtain a bit from a byte array. This method wraps the index if it is
 * out of bounds.
 * @param p_bytes   The byte array to extract a bit from.
 * @param p_index   The bit index of the wanted bit.
 * @return  The bit wanted.
 */

  protected static  final boolean get_bit   (final byte[] p_bytes,
                                             final int    p_index)
    {
    int  l_z, l_i;
    
    l_i = p_bytes.length;
    l_z = ((p_index >>> 3) % l_i);
    if(l_z < 0) l_z += l_i;
    
    l_i = ((p_index > 0) ? (p_index & 7) : ((7-((-p_index) & 7))));
    
    return (((p_bytes[l_z] >>> l_i) & 1) != 0);
    }
  
/**
 * Write a bit to a byte array. This method wraps the index if it is
 * out of bounds.
 * @param p_bytes   The byte array to write the bit to.
 * @param p_index   The bit index of the bit to be written.
 * @param p_bit     The bit to be written.
 */

  protected static  final void  set_bit   (final byte[]   p_bytes,
                                                 int      p_index,
                                           final boolean  p_bit)
    {
    int  l_z, l_i;
    
    l_i = p_bytes.length;
    l_z = ((p_index >>> 3) % l_i);
    if(l_z < 0) l_z += l_i;
    
    l_i = (1 << ((p_index > 0) ? (p_index & 7) : ((7-((-p_index) & 7)))));
    
    p_bytes[l_z] = (byte)(p_bit ? (p_bytes[l_z] | l_i)
                                : (p_bytes[l_z] & (~l_i)));
    }
  
/**
 * Toggle a bit in a byte array. This method wraps the index if it is
 * out of bounds.
 * @param p_bytes   The byte array to toggle the bit in. 
 * @param p_index   The bit index of the bit to be toggled.
 */

  protected static  final void  toggle_bit (final byte[]   p_bytes,
                                                  int      p_index)
    {
    int  l_z, l_i;
    
    l_i = p_bytes.length;
    l_z = ((p_index >>> 3) % l_i);
    if(l_z < 0) l_z += l_i;
    
    l_i = (1 << ((p_index > 0) ? (p_index & 7) : ((7-((-p_index) & 7)))));    
    p_bytes[l_z] = (byte)(p_bytes[l_z] ^ l_i);
    }
  }

File Information:

file name:CryptographicAlgorithm.java
package:org.sfc.crypt
qualified name:org.sfc.crypt.CryptographicAlgorithm.java
file type:Java Source File
download location:download http://dgpf.sourceforge.net/source/org/sfc/crypt/CryptographicAlgorithm.java
size:10.148 KB (10392 B)
uploaded: 2015-07-22 04:11:11 GMT+0000
last update: 2006-06-30 10:22:43 GMT+0000
last access: 2018-01-21 23:58:21 GMT+0000

statistics online since 2006-01-02.   RSS Feed
Contact us by sending an email to tweise@gmx.de to receive further information, to report errors, or to join our project.
All content on this site (http://dgpf.sourceforge.net/) is LGPL-licensed.
http://dgpf.sourceforge.net/scripts/source/source.php last modified at 2015-07-22 04:10:53 GMT+0000 served at 2018-01-21 23:58:21 GMT+0000.
Valid CSS Valid XHTML 1.1
Valid RSS SourceForge.net Logo