Support SHA256/512 as well

app/src/main/java/com/chameth/yaotp/algos/Hmac.kt

@@ -0,0 +1,17 @@
+package com.chameth.yaotp.algos
+
+import javax.crypto.Mac
+import javax.crypto.spec.SecretKeySpec
+
+typealias HmacFunc = (ByteArray, ByteArray) -> ByteArray
+
+fun hmacSha1(keyMaterial: ByteArray, input: ByteArray) = hmac(keyMaterial, input, "HmacSHA1")
+fun hmacSha256(keyMaterial: ByteArray, input: ByteArray) = hmac(keyMaterial, input, "HmacSHA256")
+fun hmacSha512(keyMaterial: ByteArray, input: ByteArray) = hmac(keyMaterial, input, "HmacSHA512")
+
+private fun hmac(keyMaterial: ByteArray, input: ByteArray, algorithm: String): ByteArray {
+    return with(Mac.getInstance(algorithm)) {
+        init(SecretKeySpec(keyMaterial, algorithm))
+        doFinal(input)
+    }
+}

app/src/main/java/com/chameth/yaotp/algos/Hotp.kt

@@ -4,9 +4,9 @@ import java.nio.ByteBuffer
 import kotlin.experimental.and
 import kotlin.math.pow
 
-fun hotp(key: ByteArray, counter: ByteArray, length: Int = 6) = hmacToHotp(hmacSha1(key, counter), length)
+fun hotp(key: ByteArray, counter: ByteArray, length: Int = 6, hmacFunc: HmacFunc = ::hmacSha1) = hmacToHotp(hmacFunc(key, counter), length)
 
-internal fun offsetValue(bytes: ByteArray) = (bytes[19] and 0x0F).toInt()
+internal fun offsetValue(bytes: ByteArray) = (bytes[bytes.size - 1] and 0x0F).toInt()
 
 internal fun offset(bytes: ByteArray) = offsetValue(bytes).let { bytes.sliceArray(IntRange(it, it + 3)) }
 

app/src/main/java/com/chameth/yaotp/algos/Totp.kt

@@ -2,7 +2,8 @@ package com.chameth.yaotp.algos
 
 import java.nio.ByteBuffer
 
-fun totp(key: ByteArray, startTime: Long = 0, step: Int = 30, currentTime: Long = currentTime(), length: Int = 6) = hotp(key, count(startTime, step, currentTime).toByteArray(), length)
+fun totp(key: ByteArray, startTime: Long = 0, step: Int = 30, currentTime: Long = currentTime(), length: Int = 6, hmacFunc: HmacFunc = ::hmacSha1)
+        = hotp(key, count(startTime, step, currentTime).toByteArray(), length, hmacFunc)
 
 internal fun count(startTime: Long, step: Int, currentTime: Long) = (currentTime - startTime) / step
 

app/src/main/java/com/chameth/yaotp/algos/Utils.kt

@@ -1,15 +0,0 @@
-package com.chameth.yaotp.algos
-
-import javax.crypto.Mac
-import javax.crypto.spec.SecretKeySpec
-
-private const val HMAC_SHA1_ALGORITHM = "HmacSHA1"
-
-fun hmacSha1(keyMaterial: ByteArray, input: ByteArray): ByteArray {
-    return with(Mac.getInstance(HMAC_SHA1_ALGORITHM)) {
-        init(getKey(keyMaterial))
-        doFinal(input)
-    }
-}
-
-private fun getKey(material: ByteArray) = SecretKeySpec(material, HMAC_SHA1_ALGORITHM)

app/src/test/java/com/chameth/yaotp/algos/HmacTest.kt

@@ -0,0 +1,36 @@
+package com.chameth.yaotp.algos
+
+import com.natpryce.hamkrest.assertion.assert
+import com.natpryce.hamkrest.equalTo
+import org.junit.Test
+
+class HmacTest {
+
+    @Test
+    fun testHmacSha1_withKnownValues() {
+        val key = "key".toByteArray()
+        val input = "The quick brown fox jumps over the lazy dog".toByteArray()
+        val expected = "de7c9b85b8b78aa6bc8a7a36f70a90701c9db4d9"
+
+        assert.that(hmacSha1(key, input).toHexString(), equalTo(expected))
+    }
+
+    @Test
+    fun testHmacSha256_withKnownValues() {
+        val key = "key".toByteArray()
+        val input = "The quick brown fox jumps over the lazy dog".toByteArray()
+        val expected = "f7bc83f430538424b13298e6aa6fb143ef4d59a14946175997479dbc2d1a3cd8"
+
+        assert.that(hmacSha256(key, input).toHexString(), equalTo(expected))
+    }
+
+    @Test
+    fun testHmacSha512_withKnownValues() {
+        val key = "key".toByteArray()
+        val input = "The quick brown fox jumps over the lazy dog".toByteArray()
+        val expected = "b42af09057bac1e2d41708e48a902e09b5ff7f12ab428a4fe86653c73dd248fb82f948a549f7b791a5b41915ee4d1ec3935357e4e2317250d0372afa2ebeeb3a"
+
+        assert.that(hmacSha512(key, input).toHexString(), equalTo(expected))
+    }
+
+}

app/src/test/java/com/chameth/yaotp/algos/HotpTest.kt

@@ -9,10 +9,15 @@ class HotpTest {
     private val rfcByteArray = byteArrayOfInts(0x1f, 0x86, 0x98, 0x69, 0x0e, 0x02, 0xca, 0x16, 0x61, 0x85, 0x50, 0xef, 0x7f, 0x19, 0xda, 0x8e, 0x94, 0x5b, 0x55, 0x5a)
 
     @Test
-    fun testOffsetValue_returnsLastFourBitsAsInt() {
+    fun testOffsetValue_returnsLastFourBitsAsInt_usingRfcValue() {
         assert.that(offsetValue(rfcByteArray), equalTo(10))
     }
 
+    @Test
+    fun testOffsetValue_returnsLastFourBitsAsInt_usingShorterValue() {
+        assert.that(offsetValue(byteArrayOfInts(0x55, 0x5a)), equalTo(10))
+    }
+
     @Test
     fun testOffset_returnsFourBytesAtOffsetValue() {
         assert.that(offset(rfcByteArray).toHexString(), equalTo("50ef7f19"))

app/src/test/java/com/chameth/yaotp/algos/TotpTest.kt

@@ -6,7 +6,9 @@ import org.junit.Test
 
 class TotpTest {
 
-    private val rfcKey = "12345678901234567890".toByteArray()
+    private val rfcKeySha1 = "12345678901234567890".toByteArray()
+    private val rfcKeySha256 = "12345678901234567890123456789012".toByteArray()
+    private val rfcKeySha512 = "1234567890123456789012345678901234567890123456789012345678901234".toByteArray()
 
     @Test
     fun testCount_withDefaultStepAndStart_andPastValues() {
@@ -37,12 +39,32 @@ class TotpTest {
 
     @Test
     fun testTotp_withRfcValues_usingSha1() {
-        assert.that(totp(rfcKey, 0, 30, 59, 8), equalTo(94287082))
-        assert.that(totp(rfcKey, 0, 30, 1111111109, 8), equalTo(7081804))
-        assert.that(totp(rfcKey, 0, 30, 1111111111, 8), equalTo(14050471))
-        assert.that(totp(rfcKey, 0, 30, 1234567890, 8), equalTo(89005924))
-        assert.that(totp(rfcKey, 0, 30, 2000000000, 8), equalTo(69279037))
-        assert.that(totp(rfcKey, 0, 30, 20000000000, 8), equalTo(65353130))
+        assert.that(totp(rfcKeySha1, 0, 30, 59, 8), equalTo(94287082))
+        assert.that(totp(rfcKeySha1, 0, 30, 1111111109, 8), equalTo(7081804))
+        assert.that(totp(rfcKeySha1, 0, 30, 1111111111, 8), equalTo(14050471))
+        assert.that(totp(rfcKeySha1, 0, 30, 1234567890, 8), equalTo(89005924))
+        assert.that(totp(rfcKeySha1, 0, 30, 2000000000, 8), equalTo(69279037))
+        assert.that(totp(rfcKeySha1, 0, 30, 20000000000, 8), equalTo(65353130))
+    }
+
+    @Test
+    fun testTotp_withRfcValues_usingSha256() {
+        assert.that(totp(rfcKeySha256, 0, 30, 59, 8, ::hmacSha256), equalTo(46119246))
+        assert.that(totp(rfcKeySha256, 0, 30, 1111111109, 8, ::hmacSha256), equalTo(68084774))
+        assert.that(totp(rfcKeySha256, 0, 30, 1111111111, 8, ::hmacSha256), equalTo(67062674))
+        assert.that(totp(rfcKeySha256, 0, 30, 1234567890, 8, ::hmacSha256), equalTo(91819424))
+        assert.that(totp(rfcKeySha256, 0, 30, 2000000000, 8, ::hmacSha256), equalTo(90698825))
+        assert.that(totp(rfcKeySha256, 0, 30, 20000000000, 8, ::hmacSha256), equalTo(77737706))
+    }
+
+    @Test
+    fun testTotp_withRfcValues_usingSha512() {
+        assert.that(totp(rfcKeySha512, 0, 30, 59, 8, ::hmacSha512), equalTo(90693936))
+        assert.that(totp(rfcKeySha512, 0, 30, 1111111109, 8, ::hmacSha512), equalTo(25091201))
+        assert.that(totp(rfcKeySha512, 0, 30, 1111111111, 8, ::hmacSha512), equalTo(99943326))
+        assert.that(totp(rfcKeySha512, 0, 30, 1234567890, 8, ::hmacSha512), equalTo(93441116))
+        assert.that(totp(rfcKeySha512, 0, 30, 2000000000, 8, ::hmacSha512), equalTo(38618901))
+        assert.that(totp(rfcKeySha512, 0, 30, 20000000000, 8, ::hmacSha512), equalTo(47863826))
     }
 
 }

app/src/test/java/com/chameth/yaotp/algos/UtilsTest.kt

@@ -1,18 +0,0 @@
-package com.chameth.yaotp.algos
-
-import com.natpryce.hamkrest.assertion.assert
-import com.natpryce.hamkrest.equalTo
-import org.junit.Test
-
-class UtilsTest {
-
-    @Test
-    fun testHmacSha1_withKnownValues() {
-        val key = "key".toByteArray()
-        val input = "The quick brown fox jumps over the lazy dog".toByteArray()
-        val expected = "de7c9b85b8b78aa6bc8a7a36f70a90701c9db4d9"
-
-        assert.that(hmacSha1(key, input).toHexString(), equalTo(expected))
-    }
-
-}