SecureRandom

Learn secure random with SecureRandom.

Cryptographic random with SecureRandom

SecureRandom produces cryptographically strong random values. nextBytes gives bytes; nextInt gives integers. It is slower than java.util.Random but more secure.

Example: val random = SecureRandom(); val bytes = ByteArray(8); random.nextBytes(bytes). bytes fills with 8 random bytes. This pattern is used for key and token generation. setSeed can seed it but carries predictability risk.

Generating bytes with nextBytes

SecureRandom.nextBytes(bytes) fills the given byte array with random values. This is a common way to generate keys and IVs.

Example: val key = ByteArray(16); SecureRandom().nextBytes(key). This produces a 16-byte random AES-128 key. The bytes are unpredictable; each call differs. This pattern is used to produce unique keys for each user.

Exercise Print byte size with SecureRandom

In main create val random = SecureRandom(), allocate val bytes = ByteArray(8), call random.nextBytes(bytes) and print println(bytes.size).

Show example solution

import java.security.SecureRandom

fun main() {
    val random = SecureRandom()
    val bytes = ByteArray(8)
    random.nextBytes(bytes)
    println(bytes.size)
}

Test yourself

What distinguishes SecureRandom from java.util.Random?
- It is faster
- It is less random
- It is cryptographically stronger
- It only produces Int
Show answer

It is cryptographically stronger — SecureRandom is cryptographically strong.
Match the SecureRandom parts

SecureRandom()

Object
nextBytes(bytes)

Byte generation
ByteArray(16)

Buffer
cryptographic

Strength

Complete the nextBytes call

val bytes = ByteArray(8)
SecureRandom().____(bytes)

Show answer

val bytes = ByteArray(8)
SecureRandom().nextBytes(bytes)

Next lesson: PBKDF2

We Are Enhancing Your Experience

Cookie Preferences

Strictly Necessary Cookies

Analytical Cookies