HMAC signature in Kotlin

I have legacy code written in ruby:

decoded_key = Base64.decode64('YW55IGNhcm5hbCBwbGVhc3VyZS4=')
to_sign = 'some string to sign'
bin_key = Array(decoded_key).pack('H*')
digest = OpenSSL::Digest::SHA256.new
puts OpenSSL::HMAC.hexdigest(digest, bin_key, to_sign)

You may run it HERE to see the result.

I am trying to get same result (same signature) in Kotlin.
The code i tried so far:

  val decodedKey = Base64.getDecoder().decode("YW55IGNhcm5hbCBwbGVhc3VyZS4=")
  //val binKeyHex = Hex.encodeHexString(decodedKey)
  val toSign = "some string to sign"
  val hMacSHA256 = Mac.getInstance("HmacSHA256")
  val secretKey = SecretKeySpec(decodedKey, "HmacSHA256")
  hMacSHA256.init(secretKey)
  val data = hMacSHA256.doFinal(toSign.toByteArray())

  val builder = StringBuilder()
  data.forEach { builder.append(String.format("%02X", it)) }

You may run it HERE to see the result

If we remove bin_key = Array(decoded_key).pack('H*') in ruby code and just pass decoded_key to hexdigest function - the results will be the same.
Unfortunately i can't modify ruby code, so i need to make it same in Kotlin.

How may i do the same in Kotlin to get same result?

Not a Ruby expert either, but are you sure that Array(decoded_key).pack('H*') actually results in the HEX representation of the characters of the decoded key?
The size of the output is only 10, while the decoded_key is "any carnal pleasure."

I did some experimenting with the link you provided:

puts ['an'].pack('H*') --> error "\xA7" from ASCII-8BIT to UTF-8

puts ['am'].pack('H*') --> error "\xA6" from ASCII-8BIT to UTF-8

puts ['gm'].pack('H*') --> no error, a blank line

As far as I understand, pack('H*') instructs ruby to parse the provided string as a HEX string, so in the first two cases, it sees an a and it believes that it's going to parse HEX, treating all subsequent characters modulo 15, thereby loosing a lot of info. No idea what ruby tries to do when the string starts with a non-HEX character.

The following also illustrates my point:

puts bin_key.unpack('H*') --> a720cab7a5095eacebee

Look at this:

a720cab7a5095eacebee

any carnal pleasure.

IMHO, the ruby code might be just bad practice.

(2nd go at it)
As for the pack function, I checked it in (some) Ruby source:

    for (i=0; i++ < len; ptr++) {
	if (ISALPHA(*ptr))
	    byte |= ((*ptr & 15) + 9) & 15;
	else
	    byte |= *ptr & 15;
	if (i & 1)
	    byte <<= 4;
	else {
	    char c = castchar(byte);
	    rb_str_buf_cat(res, &c, 1);
	    byte = 0;
	}
    }

So it will treat all letters a-zA-Z the same: mod 16, +9 , mod 16.
For chars that are not a-zA-Z, it will just do mod 16.

Here's how to compute the same HMAC in Kotlin:

import java.util.Base64
import kotlin.math.abs
import kotlin.text.*
import javax.crypto.*
import javax.crypto.spec.*
import kotlin.experimental.and

fun main() {
  val decodedKey = Base64.getDecoder().decode("YW55IGNhcm5hbCBwbGVhc3VyZS4=")
  val builder2 = StringBuilder()
  var key = ByteArray(decodedKey.size)
  var i=0;
  decodedKey.forEachIndexed { nr, it -> 
      var c:Char = it.toChar()
      val v = if (c.isLetter()) ((it and 15) + 9) and 15 else it and 15
      builder2.append(String.format("%01X", v ))
      if ( (nr and 1) > 0 ){
          key[i] = (key[i] + v.toByte()).toByte()
          i += 1
      }
      else
      {
          key[i] = ( key[i] + ((v.toInt()).shl(4)).toByte() ).toByte()
      }
  }
  println(builder2)
  
  val toSign = "some string to sign"
  val hMacSHA256 = Mac.getInstance("HmacSHA256")
  val secretKey = SecretKeySpec(key, "HmacSHA256")
  hMacSHA256.init(secretKey)
  val data = hMacSHA256.doFinal(toSign.toByteArray())

  val builder = StringBuilder()
  data.forEach { builder.append(String.format("%02X", it)) }
  println(builder)
}