A modern programming language that makes developers happier.

kotlinlang

I’m implementing this <https://www.rabbitmq.com/passwords.html#computing-password-hash>, how can I generate this as a byte array in kotlin? `908D C60A` note: I don’t mean generate a salt I mean literally these bytes, I’m trying to test my algorithm and see if I get the same base64 encoded string

`Byte` is signed by default in Kotlin, so `0x90` is out of range - you could use the experimental unsigned types but that might open up a different can of worms

assuming by “generate this as a byte array” you mean, like, assign this as a literal to compare against, then you’d want something like this I think:
```
ubyteArrayOf(0x90u, 0x8Du, 0xC6u, 0x0Au)
```

actually, it will work just fine without unsigned

how do you mean? am I thinking about this the wrong way?

it will just be negative if you read it without additional transformation

what I was more trying to address is the fact you still can’t do, like, `byteArrayOf(0x90)`, since that’s a compile error

could call `.toByte()` on each int I guess :grimacing:

I wonder if they’re supposed to be characters

&gt; Concatenate that with the UTF-8 representation of the password (in this case `test12`): `908D C60A 7465 7374 3132`

though I haven’t been able to figure out how they’re encoded for that encoding to line up with `test12`

unfortunately I also don’t know :sweat_smile:

so, you're working with bytes entire time, until you do base64 conversion

<@UHM5QMQ81> so how’re you suggesting I write it? I’m not used to working with raw bytes, especially not like this

is `ubyteArrayOf` new in 1.3? if so… I’m still using 1.2

```
import kotlin.random.Random
import kotlin.text.Charsets.UTF_8

fun a(pass: String, seed: Long): String {
    val random = Random(seed)
    val salt: ByteArray = random.nextBytes(4)

    val passBytes = pass.toByteArray(charset = UTF_8)
    val toHash = salt + passBytes
    val hashed = sha256(toHash)
    return toBase64(salt + hashed)
}

fun sha256(toHash: ByteArray): ByteArray {
    TODO("not implemented")
}

fun toBase64(bytes: ByteArray): String {
    TODO("not implemented")
}
```

sha256, base64 (and random/seed) might depend on your platform

yeah I’ve got an implementation from spring

<https://stackoverflow.com/q/57617285/206466>