生成Java Card中两个数字之间的随机数字

Question

如何生成Java Card中两个数字之间的随机数字？例如，编号应该在0到50之间生成。

Answer 1

这里有examples这里。以从该链接的例子2：

import java.util.Random; 

/** Generate random integers in a certain range. */ 
public final class RandomRange { 

public static final void main(String... aArgs){ 
    log("Generating random integers in the range 1..10."); 

    int START = 1; 
    int END = 10; 
    Random random = new Random(); 
    for (int idx = 1; idx <= 10; ++idx){ 
    showRandomInteger(START, END, random); 
    } 

    log("Done."); 
} 

private static void showRandomInteger(int aStart, int aEnd, Random aRandom){ 
    if (aStart > aEnd) { 
    throw new IllegalArgumentException("Start cannot exceed End."); 
} 
//get the range, casting to long to avoid overflow problems 
long range = (long)aEnd - (long)aStart + 1; 
// compute a fraction of the range, 0 <= frac < range 
long fraction = (long)(range * aRandom.nextDouble()); 
int randomNumber = (int)(fraction + aStart);  
log("Generated : " + randomNumber); 
} 

private static void log(String aMessage){ 
System.out.println(aMessage); 
} 
} 

Answer 2

使用RandomData抽象类：

http://www.win.tue.nl/pinpasjc/docs/apis/jc222/javacard/security/RandomData.html

编辑：

这里是这个类中使用的的exaple，

byte[] keyBytes = JCSystem.getTransientByteArray(COD,16); 

RandomData rng = RandomData.getInstance(ALG_SECURE_RANDOM); 
rng.generateData(keyBytes,0,16); 

如果您只是寻找随机数而不是randomData您可以使用此：

/* 
    * generate a random number between 0 and 50 
    */ 
    Random random1 = new Random(); 
    int card = (random1.nextInt(51)); 

Answer 3

在Java卡，你只能访问到javacard.security.RandomData，这是唯一能够生成随机字节。

首先需要正确类型的变量：

private RandomData rng; 
private byte[] rndBuffer; 

然后，你需要下面的代码在构造函数/安装（避免分配一个随机数发生器和缓冲器每次）：

rng = RandomData.getInstance(RandomData.ALG_SECURE_RANDOM); 
rndBuffer = JCSystem.getTransientByteArray(JCSystem.CLEAR_ON_DESELECT, 1); 

然后，你可以定义你的方法得到的范围内的随机字节：

byte getRandomByteInRange(byte min, byte max) { 
    do { 
    rng.generateData(rndBuffer,0,1); 
    while ((rndBuffer[0]<min) || (rndBuffer[0]>max)) 
    return rndBuffer[0]; 
} 

写这种方法很可能不会那么愚蠢（特别是对于小范围），但它应该起作用。

Answer 4

被这个问题所吸引，我决定再次通过StackOverflow做一些代码贡献。请注意，我仅在Java SE中使用SecureRandom测试了随机数的分布。我相当确定这段代码是正确的。

所以没有进一步的话，代码。

package nl.owlstead.jcsecurerandom; 

import javacard.framework.JCSystem; 
import javacard.framework.Util; 
import javacard.security.RandomData; 

/** 
* Generates numbers within a range. This class uses modulo arithmetic to 
* minimize the number of calls to the random number generator without expensive 
* calculations. The class is similar in operation to the 
* {@code SecureRandom.nextInt(int)} method defined in Java SE. 
* 
* @author owlstead 
*/ 
public final class JCSecureRandom { 

    private static final short SHORT_SIZE_BYTES = 2; 
    private static final short START = 0; 

    private final RandomData rnd; 
    private final byte[] buf; 

    /** 
    * Constructor which uses the given source of random bytes. A two byte 
    * buffer transient buffer is generated that is cleared on deselect. 
    * 
    * @param rnd 
    *   the source of random bytes 
    */ 
    public JCSecureRandom(final RandomData rnd) { 
     this.rnd = rnd; 
     this.buf = JCSystem.makeTransientByteArray(SHORT_SIZE_BYTES, 
       JCSystem.CLEAR_ON_DESELECT); 
    } 

    /** 
    * Generates a single short with a random value in the range of 0 
    * (inclusive) to the given parameter n (exclusive). 
    * 
    * @param n 
    *   the upper bound of the random value, must be positive 
    *   (exclusive) 
    * @return the random value in the range [0..n-1] 
    */ 
    public short nextShort(final short n) { 
     final short sn = (short) (n - 1); 
     short bits, val; 
     do { 
      bits = next15(); 
      val = (short) (bits % n); 
     } while ((short) (bits - val + sn) < 0); 
     return val; 
    } 

    /** 
    * Generates a single byte with a random value in the range of 0 (inclusive) 
    * to the given parameter n (exclusive). 
    * 
    * @param n 
    *   the upper bound of the random value, must be positive 
    *   (exclusive) 
    * @return the random value in the range [0..n-1] 
    */ 
    public byte nextByte(final byte n) { 
     if ((n & -n) == n) { 
      return (byte) ((n * next7()) >> 7); 
     } 

     final byte sn = (byte) (n - 1); 
     byte bits, val; 
     do { 
      bits = next7(); 
      val = (byte) (bits % n); 
     } while ((byte) (bits - val + sn) < 0); 
     return val; 
    } 

    /** 
    * Generates 15 bits from two bytes by setting the highest bit to zero. 
    * 
    * @return the positive valued short containing 15 bits of random 
    */ 
    private short next15() { 
     this.rnd.generateData(this.buf, START, SHORT_SIZE_BYTES); 
     return (short) (Util.getShort(this.buf, START) & 0x7FFF); 
    } 

    /** 
    * Generates 7 bits from one byte by setting the highest bit to zero. 
    * 
    * @return the positive valued byte containing 7 bits of random 
    */ 
    private byte next7() { 
     this.rnd.generateData(this.buf, START, SHORT_SIZE_BYTES); 
     return (byte) (this.buf[START] & 0x7F); 
    } 
}