Генерировать случайное число, ограниченное между двумя номерами в Java-карте

Question

Как создать случайное число, ограниченное между двумя номерами на Java-карте? Например, номер должен быть сгенерирован между 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

Edit:

здесь является 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 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 4

Будучи заинтригованным этим вопросом, я снова решил внести некоторые вклады в код через StackOverflow. Обратите внимание, что я проверил только распределение случайных чисел, используя SecureRandom в Java SE. Я уверен, что этот код правильный.

Итак, без дальнейших церемоний, код.

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