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

Question

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

Answer 1

请注意，我只使用SecureRandomJava SE 测试了随机数的分布。我有理由确定这段代码是正确的。该代码使用 NIST 定义的“简单拒绝”方法。

废话不多说，上代码。

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);
    }
}

Answer 2

在 Java Card 中，您只能访问 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 3

这里有 例子。以该链接中的示例 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 4

使用 RandomData 抽象类：

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

编辑：

这是使用中的此类的一个示例，

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));