ideatest.java

MPI for java for Distributed Programming

/**************************************************************************
*                                                                         *
*             Java Grande Forum Benchmark Suite - MPJ Version 1.0         *
*                                                                         *
*                            produced by                                  *
*                                                                         *
*                  Java Grande Benchmarking Project                       *
*                                                                         *
*                                at                                       *
*                                                                         *
*                Edinburgh Parallel Computing Centre                      *
*                                                                         * 
*                email: [e-mail]                     *
*                                                                         *
*                  Original version of this code by                       *
*                 Gabriel Zachmann ([e-mail])                      *
*                                                                         *
*      This version copyright (c) The University of Edinburgh, 2001.      *
*                         All rights reserved.                            *
*                                                                         *
**************************************************************************/


/**
* Class IDEATest
*
* This test performs IDEA encryption then decryption. IDEA stands
* for International Data Encryption Algorithm. The test is based
* on code presented in Applied Cryptography by Bruce Schnier,
* which was based on code developed by Xuejia Lai and James L.
* Massey.

**/

package jgf_mpj_benchmarks.section2.crypt;

import java.util.*;
import jgf_mpj_benchmarks.jgfutil.*; 
import mpi.*;

class IDEATest
{

// Declare class data. Byte buffer plain1 holds the original
// data for encryption, crypt1 holds the encrypted data, and
// plain2 holds the decrypted data, which should match plain1
// byte for byte.

int array_rows; 
int p_array_rows;
int ref_p_array_rows;
int rem_p_array_rows;

byte [] plain1 = null;       // Buffer for plaintext data.
byte [] crypt1 = null;       // Buffer for encrypted data.
byte [] plain2 = null;       // Buffer for decrypted data.

byte [] p_plain1 = null;
byte [] p_crypt1 = null;
byte [] p_plain2 = null;

short [] userkey;     // Key for encryption/decryption.
int [] Z;             // Encryption subkey (userkey derived).
int [] DK;            // Decryption subkey (userkey derived).



void Do() throws MPIException
{

  // temporary array for MPI
  int m_length;

  MPI.COMM_WORLD.Barrier();
  // Start the stopwatch.       
  if(JGFCryptBench.rank==0) {
    JGFInstrumentor.startTimer("Section2:Crypt:Kernel"); 		
  }

  // broadcast information
  if(JGFCryptBench.rank==0) {
    for (int i = 0; i < p_array_rows; i++) {
     p_plain1[i] = plain1[i]; 
    }
    for(int k=1;k<JGFCryptBench.nprocess;k++){
     if(k==JGFCryptBench.nprocess-1) {
       m_length = rem_p_array_rows;
     } else {
       m_length = p_array_rows;
     }
     MPI.COMM_WORLD.Ssend(plain1,(p_array_rows*k),m_length,MPI.BYTE,k,k);
    }
  } else {
    MPI.COMM_WORLD.Recv(p_plain1,0,p_array_rows,MPI.BYTE,0,JGFCryptBench.rank);
  }

  cipher_idea(p_plain1, p_crypt1, Z);     // Encrypt plain1.
  cipher_idea(p_crypt1, p_plain2, DK);    // Decrypt.

  MPI.COMM_WORLD.Barrier();

  if(JGFCryptBench.rank==0) {
    for(int k=0; k<p_array_rows;k++){ 
      plain2[k] = p_plain2[k];
    }

    for(int k=1;k<JGFCryptBench.nprocess;k++) {
      MPI.COMM_WORLD.Recv(plain2,(p_array_rows*k),p_array_rows,MPI.BYTE,k,k);
    }
  } else {
    MPI.COMM_WORLD.Ssend(p_plain2,0,p_array_rows,MPI.BYTE,0,JGFCryptBench.rank);
  }

  MPI.COMM_WORLD.Barrier();

  // Stop the stopwatch.
  if(JGFCryptBench.rank==0) {
    JGFInstrumentor.stopTimer("Section2:Crypt:Kernel");
  }
}

/*
* buildTestData
*
* Builds the data used for the test -- each time the test is run.
*/

void buildTestData()
{


    // Create three byte arrays that will be used (and reused) for
    // encryption/decryption operations.

    if(JGFCryptBench.rank==0) {
      plain1 = new byte [array_rows];
      crypt1 = new byte [array_rows];
      plain2 = new byte [array_rows];
    } 

    p_plain1 = new byte [p_array_rows];
    p_crypt1 = new byte [p_array_rows];
    p_plain2 = new byte [p_array_rows];

    Random rndnum = new Random(136506717L);  // Create random number generator.


    // Allocate three arrays to hold keys: userkey is the 128-bit key.
    // Z is the set of 16-bit encryption subkeys derived from userkey,
    // while DK is the set of 16-bit decryption subkeys also derived
    // from userkey. NOTE: The 16-bit values are stored here in
    // 32-bit int arrays so that the values may be used in calculations
    // as if they are unsigned. Each 64-bit block of plaintext goes
    // through eight processing rounds involving six of the subkeys
    // then a final output transform with four of the keys; (8 * 6)
    // + 4 = 52 subkeys.

    userkey = new short [8];  // User key has 8 16-bit shorts.
    Z = new int [52];         // Encryption subkey (user key derived).
    DK = new int [52];        // Decryption subkey (user key derived).

    // Generate user key randomly; eight 16-bit values in an array.

    for (int i = 0; i < 8; i++)
    {
        // Again, the random number function returns int. Converting
        // to a short type preserves the bit pattern in the lower 16
        // bits of the int and discards the rest.

      userkey[i] = (short) rndnum.nextInt();
    }

    // Compute encryption and decryption subkeys.

    calcEncryptKey();
    calcDecryptKey();

    // Fill plain1 with "text."
    // do on process 0 for reference 

    if(JGFCryptBench.rank==0) {    
      for (int i = 0; i < array_rows; i++)
      {
        plain1[i] = (byte) i; 

        // Converting to a byte
        // type preserves the bit pattern in the lower 8 bits of the
        // int and discards the rest.
      }
    }

}

/*
* calcEncryptKey
*
* Builds the 52 16-bit encryption subkeys Z[] from the user key and
* stores in 32-bit int array. The routing corrects an error in the
* source code in the Schnier book. Basically, the sense of the 7-
* and 9-bit shifts are reversed. It still works reversed, but would
* encrypted code would not decrypt with someone else's IDEA code.
*/

private void calcEncryptKey()
{
    int j;                       // Utility variable.

    for (int i = 0; i < 52; i++) // Zero out the 52-int Z array.
        Z[i] = 0;

    for (int i = 0; i < 8; i++)  // First 8 subkeys are userkey itself.
    {
        Z[i] = userkey[i] & 0xffff;     // Convert "unsigned"
                                        // short to int.
    }

    // Each set of 8 subkeys thereafter is derived from left rotating
    // the whole 128-bit key 25 bits to left (once between each set of
    // eight keys and then before the last four). Instead of actually
    // rotating the whole key, this routine just grabs the 16 bits
    // that are 25 bits to the right of the corresponding subkey
    // eight positions below the current subkey. That 16-bit extent
    // straddles two array members, so bits are shifted left in one
    // member and right (with zero fill) in the other. For the last
    // two subkeys in any group of eight, those 16 bits start to
    // wrap around to the first two members of the previous eight.

    for (int i = 8; i < 52; i++)
    {
        j = i % 8;
        if (j < 6)
        {
            Z[i] = ((Z[i -7]>>>9) | (Z[i-6]<<7)) // Shift and combine.
                    & 0xFFFF;                    // Just 16 bits.
            continue;                            // Next iteration.
        }

        if (j == 6)    // Wrap to beginning for second chunk.
        {
            Z[i] = ((Z[i -7]>>>9) | (Z[i-14]<<7))
                    & 0xFFFF;
            continue;
        }

         // j == 7 so wrap to beginning for both chunks.

        Z[i] = ((Z[i -15]>>>9) | (Z[i-14]<<7))
                    & 0xFFFF;
    }
}

/*
* calcDecryptKey
*
* Builds the 52 16-bit encryption subkeys DK[] from the encryption-
* subkeys Z[]. DK[] is a 32-bit int array holding 16-bit values as
* unsigned.
*/

private void calcDecryptKey()
{
    int j, k;                 // Index counters.
    int t1, t2, t3;           // Temps to hold decrypt subkeys.

    t1 = inv(Z[0]);           // Multiplicative inverse (mod x10001).
    t2 = - Z[1] & 0xffff;     // Additive inverse, 2nd encrypt subkey.
    t3 = - Z[2] & 0xffff;     // Additive inverse, 3rd encrypt subkey.

    DK[51] = inv(Z[3]);       // Multiplicative inverse (mod x10001).
    DK[50] = t3;
    DK[49] = t2;
    DK[48] = t1;

    j = 47;                   // Indices into temp and encrypt arrays.
    k = 4;
    for (int i = 0; i < 7; i++)
    {