random.java

我学密码学时做的作业

package ran;

import des.*;
import java.util.Calendar;
/**
 *
 * <p>Title:随机数 </p>
 * <p>Description:利用des生成随机数 </p>
 * <p>Copyright: Copyright (c) 2006</p>
 * <p>Company: </p>
 * @author maya
 * @version 1.0
 */
public class Random {
  /**
   * 产生的随机序列，存放在64比特的长整型数据数组中
   */
  private long[] sequence;
  /**
   * 产生的随机数数组的长度，即sequence数组的长度
   */
  private int sqLength;

  /**
   * 构造函数
   */
  public Random() {
  }

  /**
   * 返回随机序列数组
   * @return long[]
   */
  public long[] getSequence(){
    return this.sequence;
  }

  /**
   * 利用系统的年月日信息初始化V1
   * @return byte[]  生成的64bit数据存放在64个byte类型的数组中
   */
  private byte[] setV1(){

     Calendar cal=Calendar.getInstance();
     byte[] date=new byte[8];
     byte[] v1=new byte[64];
     int day=cal.get(Calendar.DAY_OF_MONTH);
     int month=cal.get(Calendar.MONTH);
     int year=cal.get(Calendar.YEAR);
     int i;
     for(i=0;i<=1;i++){
        date[i]=(byte)(day%10);
        day=day/10;
     }
     for(i=2;i<=3;i++){
        date[i]=(byte)(month%10);
        month=month/10;
     }
     for(i=4;i<=7;i++){
        date[i]=(byte)(year%10);
        year=year/10;
    }
     for (i = 0; i<8; i++) {
        for(int k=7;k>=0;k--){
             v1[8*i+k]=(byte)(date[i]%2);
             date[i]=(byte)(date[i]/2);
        }
     }
     return v1;
  }

  /**
   * 利用系统时间初始化Z1
   * @return byte[] 生成的64bit数据存放在64个byte类型的数组中并返回
   */
  private byte[] setZ1(){

    byte[] z1=new byte[64];
    long time=System.currentTimeMillis();
    System.out.println("time:");
    System.out.println(time);
    for(int i=0;i<64;i++){
      z1[i]=(byte)(time%2);
      time=(long)time/2;
    }
    return z1;
  }

  /**
   * 随机序列生成
   * @param num int  生成的随机序列的长度，num定义sequence数组的长度
   * @param key1 String    k1密钥
   * @param key2 String    k2密钥
   */
  public void setRndmSequence(int num,String key1,String key2){

    Des des1=new Des(key1);
    Des des2=new Des(key2);
    Des des3=new Des();
    byte[] z;
    byte[] v;
    byte[] x;
    byte[] w;
    byte[] r;
    v=setV1();
    z=setZ1();
    this.sqLength=num;
    this.sequence=new long[num];
    for(int i=0;i<num;i++){
       //计算Xi
       des1.setWorkData(v);
       des1.enc();
       x=des1.getOutput();
       //计算Wi
       des3.setKey(x);
       des3.setWorkData(v);
       des3.dec();
       w=des3.getOutput();
       //计算Yi
       des3.setKey(z);
       des3.setWorkData(x);
       des3.dec();
       v=des3.getOutput();
       //计算Vi+1
       des2.setWorkData(v);
       des2.enc();
       v=des2.getOutput();
       //最后得到随机数
       des2.setWorkData(w);
       des2.enc();
       r=des2.getOutput();
       //64比特信息放到长整型数组中
       sequence[i]=this.cnvt64BytesToLong(r);
       //计算密钥Zi
       des1.setWorkData(z);
       des1.dec();
       z=des1.getOutput();
    }
 }

 /**
  * 将存放在byte[]类型的64位比特数据转为长整型
  * @param v byte[]  要转化的长度为64的byte数组，每byte元素存放一个bit信息
  * @return long     保存64比特信息的长整型
  */
 public long cnvt64BytesToLong(byte[] v){
    long lv=0;
    for(int i=63;i>=0;i--){
      lv=(lv<<1)+v[i];
      System.out.print(v[i]);
    }
    System.out.print("\n");
    return lv;

  }

  /**
   * 将存放在长整型中的64比特信息提取出来转放在长度为64的byte数组中
   * @param v long  要转化的长整型
   * @return byte[] 返回长度为64bit的byte型数组，每个元素存放一个比特信息
   */
  public byte[] cnvtLongTo64Bytes(long v){
    byte[] V=new byte[64];
    long b=1;
    for(int i=63;i>=0;i--){
       long c=v&b;
       if(c!=0) V[i]=1; else V[i]=0;
       b=b<<1;
       }
    return V;

  }

  /**
   * 计算随机序列的游程数目，供测试随机序列的性质试验用
   * @return int[]  返回各游程的计数
   */
  public int[] countYC(){

    long[] B=new long[sqLength];
    int[] y=new int[1000];      //游程统计结果数组
    long a=0x8000000000000000L;
    long b=0x8000000000000000L;
    int c=0;   //游程值，初始设置1
    int i,j;
    if((sequence[0]&a)==0){
       b=0L;
    }
    for(i=0;i<sqLength;i++){
       B[i]=sequence[i];
    }
    //游程统计
    for(i=0;i<B.length;i++){
       for(j=0;j<64;j++){
            if((B[i]&a)==b){
               c++;    //游程值加1
            }else{
               y[c]++;    //游程为c的统计数目加1
               c=1;
               b=b^a;
            }
            B[i]=B[i]<<1;  //左移一位
       }

    }
    return y;
  }

  /**
   * 随机序列数组的循环移位操作
   * @param B long[]  放在长整型数组中的随机序列
   * @param n int  长整型数组的个数
   * @param m int  循环移位的次数
   */
  public void shift(long[] B,int n,int m){

     long a=0x8000000000000000L;
     boolean flag;
     int i,j;
     //循环左移m次
     for(i=0;i<m;i++){
       //记录最左比特信息
       if((B[0]&a)!=0)
        flag=true;
       else flag=false;
       //各数组元素左移一位，其中第j+1数组元素的最左元素置入j数组元素的最右端
       for(j=0;j<n-1;j++){
         B[j]=B[j]<<1;
           if((B[j+1]&a)!=0){
               B[j]=B[j]+1;
           }
        }
        //串最左比特置入最右端
        B[n-1]=B[n-1]<<1;
        if(flag) B[n-1]+=1;
       }
   }

   /**
    * 生成的随机序列的自相关和异相自相关计算，供测试随机序列的性质试验用
    * @param n int   自相关t的取值范围：0—n
    * @param m int   自相关t的取值间距
    * @return double[]   自相关R(t)值以double数组返回
    */
   public double[] rt(int n,int m){

     int i,j,t,b,nt,dt;
     double[] R=new double[n];
     long[] A=new long[sqLength];
     long[] C=new long[sqLength];
     for(i=0;i<sqLength;i++){
        A[i]=sequence[i];
     }
     int num=64*sqLength;
     //相关运算，计算t个值
     for(t=0;t<n;t++){
       nt=0;
       dt=0;
       for(i=0;i<sqLength;i++){
          C[i]=A[i]^sequence[i];
       }
       for(i=0;i<sqLength;i++){
           b=1;
           for(j=0;j<64;j++){
              if((C[i]&b)==0) nt++; //nt 计数原序列和移位序列之间相同的bit数目
              else dt++; //nt 计数原序列和移位序列之间不相同的bit数目
              b=b<<1;
           }
        }
       R[t]=1.0*(nt-dt)/num;  //相关值
       //串循环左移m位
       shift(A,sqLength,m);
     }
     return R;
   }

   /**
    * 获得随机序列组中0比特的个数，供测试随机序列的性质试验用
    * @return int  返回比特为0的个数
    */
   public int count0bits(){
     int num=0;
     for(int i=0;i<sqLength;i++){
       long b=1;
       for(int j=0;j<64;j++){
         if((sequence[i]&b)==0) num++;
         b=b<<1;
       }
     }
     return num;
   }


}