Add account classes and URI parser

app/src/main/java/com/chameth/yaotp/accounts/Accounts.kt

@@ -0,0 +1,8 @@
+package com.chameth.yaotp.accounts
+
+import com.chameth.yaotp.algos.HotpParams
+import com.chameth.yaotp.algos.TotpParams
+
+sealed class Account(val label: String, val issuer: String? = null)
+class HotpAccount(label: String, issuer: String?, val counter: Long, val params: HotpParams) : Account(label, issuer)
+class TotpAccount(label: String, issuer: String?, val params: TotpParams) : Account(label, issuer)

app/src/main/java/com/chameth/yaotp/accounts/UriParser.kt

@@ -0,0 +1,55 @@
+package com.chameth.yaotp.accounts
+
+import com.chameth.yaotp.algos.HotpParams
+import com.chameth.yaotp.algos.TotpParams
+import com.chameth.yaotp.algos.getHmacFunc
+import com.chameth.yaotp.util.base32Decode
+import java.net.URI
+
+fun parseUri(uri: String) : Account? {
+    return try {
+        toAccount(URI.create(uri))
+    } catch (_ : Exception) {
+        null
+    }
+}
+
+@Throws(IllegalArgumentException::class)
+internal fun toAccount(uri: URI): Account? {
+    require(uri.scheme == "otpauth") { "Scheme must be 'otpauth', got '${uri.scheme}'" }
+    require(uri.path.length > 1) { "No label specified" }
+    requireNotNull(uri.query) { "No query string supplied" }
+
+    val label = uri.path.substring(1)
+    val params = uri.queryParameters()
+    require("secret" in params) { "No 'secret' parameter specified, got ${params.keys}"}
+
+    return when(uri.host) {
+        "hotp" -> getHotpAccount(label, params)
+        "totp" -> getTotpAccount(label, params)
+        else -> throw IllegalArgumentException("Unrecognised type: ${uri.host}")
+    }
+}
+
+internal fun getHotpAccount(label: String, uriParams: Map<String, String>): HotpAccount {
+    val counter = uriParams["counter"]?.toLongOrNull()
+    requireNotNull(counter) { "No 'counter' parameter specified for HOTP" }
+    return HotpAccount(label, uriParams["issuer"], counter!!, getHotpParameters(uriParams))
+}
+
+fun getTotpAccount(label: String, uriParams: Map<String, String>): TotpAccount {
+    val step = uriParams["step"]?.toIntOrNull() ?: 30
+    return TotpAccount(label, uriParams["issuer"], TotpParams(getHotpParameters(uriParams), step = step))
+}
+
+internal fun getHotpParameters(uriParams : Map<String, String>) : HotpParams {
+    return HotpParams(
+            base32Decode(uriParams["secret"] ?: ""),
+            uriParams["digits"]?.toIntOrNull() ?: 6,
+            getHmacFunc(uriParams["algorithm"])
+    )
+}
+
+internal fun URI.queryParameters(): Map<String, String> {
+    return query.split('&').map { with(it.split('=', limit = 2)) { this[0] to this[1] } }.toMap()
+}

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

@@ -5,6 +5,15 @@ import javax.crypto.spec.SecretKeySpec
 
 typealias HmacFunc = (ByteArray, ByteArray) -> ByteArray
 
+fun getHmacFunc(name: String?): HmacFunc {
+    return when (name?.toLowerCase()) {
+        "sha1" -> ::hmacSha1
+        "sha256" -> ::hmacSha256
+        "sha512" -> ::hmacSha512
+        else -> ::hmacSha1
+    }
+}
+
 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")

app/src/test/java/com/chameth/yaotp/accounts/UriParserTest.kt

@@ -0,0 +1,139 @@
+package com.chameth.yaotp.accounts
+
+import com.chameth.yaotp.algos.hmacSha1
+import com.chameth.yaotp.algos.hmacSha256
+import com.chameth.yaotp.algos.hmacSha512
+import com.chameth.yaotp.toHexString
+import org.junit.Assert
+import org.junit.Rule
+import org.junit.Test
+import org.junit.rules.ExpectedException
+import java.net.URI
+
+class UriParserTest {
+
+    @get:Rule
+    val expectedExceptionRule = ExpectedException.none()
+
+    @Test
+    fun testToAccount_throwsForInvalidScheme() {
+        expectedExceptionRule.expect(IllegalArgumentException::class.java)
+        expectedExceptionRule.expectMessage("Scheme must be 'otpauth', got 'foo'")
+
+        toAccount(URI.create("foo://hotp/baz?secret=23"))
+    }
+
+    @Test
+    fun testToAccount_throwsForInvalidType() {
+        expectedExceptionRule.expect(IllegalArgumentException::class.java)
+        expectedExceptionRule.expectMessage("Unrecognised type: bar")
+
+        toAccount(URI.create("otpauth://bar/baz?secret=23"))
+    }
+
+    @Test
+    fun testToAccount_throwsForMissingLabel() {
+        expectedExceptionRule.expect(IllegalArgumentException::class.java)
+        expectedExceptionRule.expectMessage("No label specified")
+
+        toAccount(URI.create("otpauth://hotp/?secret=23"))
+    }
+
+    @Test
+    fun testToAccount_throwsForNoQueryString() {
+        expectedExceptionRule.expect(IllegalArgumentException::class.java)
+        expectedExceptionRule.expectMessage("No query string supplied")
+
+        toAccount(URI.create("otpauth://totp/foo"))
+    }
+
+    @Test
+    fun testToAccount_throwsForNoSecret() {
+        expectedExceptionRule.expect(IllegalArgumentException::class.java)
+        expectedExceptionRule.expectMessage("No 'secret' parameter specified, got [secrat]")
+
+        toAccount(URI.create("otpauth://totp/foo?secrat=23"))
+    }
+
+    @Test
+    fun testToAccount_throwsForNoCounter() {
+        expectedExceptionRule.expect(IllegalArgumentException::class.java)
+        expectedExceptionRule.expectMessage("No 'counter' parameter specified for HOTP")
+
+        toAccount(URI.create("otpauth://hotp/foo?secret=23"))
+    }
+
+    @Test
+    fun testToAccount_returnsHotpAccount_withDefaultArgs() {
+        val account = toAccount(URI.create("otpauth://hotp/foo?secret=ABC234&counter=123")) as HotpAccount
+        Assert.assertNull(account.issuer)
+        Assert.assertEquals("foo", account.label)
+        Assert.assertEquals(::hmacSha1, account.params.hmacFunc)
+        Assert.assertEquals(6, account.params.length)
+        Assert.assertEquals("0045adf4", account.params.key.toHexString())
+        Assert.assertEquals(123L, account.counter)
+    }
+
+    @Test
+    fun testToAccount_returnsHotpAccount_withIssuer() {
+        val account = toAccount(URI.create("otpauth://hotp/foo?secret=ABC234&issuer=BigCorp%20Inc&counter=0")) as HotpAccount
+        Assert.assertEquals("BigCorp Inc", account.issuer)
+    }
+
+    @Test
+    fun testToAccount_returnsHotpAccount_withCustomDigits() {
+        val account = toAccount(URI.create("otpauth://hotp/foo?secret=ABC234&digits=8&counter=0")) as HotpAccount
+        Assert.assertEquals(8, account.params.length)
+    }
+
+    @Test
+    fun testToAccount_returnsHotpAccount_withInvalidDigits() {
+        val account = toAccount(URI.create("otpauth://hotp/foo?secret=ABC234&digits=HALLO&counter=0")) as HotpAccount
+        Assert.assertEquals(6, account.params.length)
+    }
+
+    @Test
+    fun testToAccount_returnsHotpAccount_withSha256() {
+        val account = toAccount(URI.create("otpauth://hotp/foo?secret=ABC234&algorithm=Sha256&counter=0")) as HotpAccount
+        Assert.assertEquals(::hmacSha256, account.params.hmacFunc)
+    }
+
+    @Test
+    fun testToAccount_returnsHotpAccount_withSha512() {
+        val account = toAccount(URI.create("otpauth://hotp/foo?secret=ABC234&algorithm=SHA512&counter=0")) as HotpAccount
+        Assert.assertEquals(::hmacSha512, account.params.hmacFunc)
+    }
+
+    @Test
+    fun testToAccount_returnsTotpAccount_withDefaultArgs() {
+        val account = toAccount(URI.create("otpauth://totp/foo?secret=ABC234")) as TotpAccount
+        Assert.assertNull(account.issuer)
+        Assert.assertEquals("foo", account.label)
+        Assert.assertEquals(::hmacSha1, account.params.hotpParams.hmacFunc)
+        Assert.assertEquals(6, account.params.hotpParams.length)
+        Assert.assertEquals("0045adf4", account.params.hotpParams.key.toHexString())
+        Assert.assertEquals(0, account.params.startTime)
+        Assert.assertEquals(30, account.params.step)
+    }
+
+    @Test
+    fun testToAccount_returnsTotpAccount_withCustomStep() {
+        val account = toAccount(URI.create("otpauth://totp/foo?secret=ABC234&step=60")) as TotpAccount
+        Assert.assertEquals(60, account.params.step)
+    }
+
+    @Test
+    fun testParseUri_returnsAccountIfValid() {
+        Assert.assertNotNull(parseUri("otpauth://totp/foo?secret=ABC234&step=60"))
+        Assert.assertNotNull(parseUri("otpauth://hotp/foo?secret=ABC234&counter=60"))
+    }
+
+    @Test
+    fun testParseUri_returnsNullIfInvalid() {
+        Assert.assertNull(parseUri(""))
+        Assert.assertNull(parseUri("NOT A URI"))
+        Assert.assertNull(parseUri("foo://hotp/baz?secret=23"))
+        Assert.assertNull(parseUri("otpauth://hotp/baz?secret=23"))
+    }
+
+}

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

@@ -3,6 +3,7 @@ package com.chameth.yaotp.algos
 import com.chameth.yaotp.toHexString
 import com.natpryce.hamkrest.assertion.assert
 import com.natpryce.hamkrest.equalTo
+import org.junit.Assert
 import org.junit.Test
 
 class HmacTest {
@@ -34,4 +35,29 @@ class HmacTest {
         assert.that(hmacSha512(key, input).toHexString(), equalTo(expected))
     }
 
+    @Test
+    fun testGetHmacFunc_defaultsToSha1() {
+        Assert.assertEquals(::hmacSha1, getHmacFunc(null))
+        Assert.assertEquals(::hmacSha1, getHmacFunc("foo"))
+        Assert.assertEquals(::hmacSha1, getHmacFunc("sha25618"))
+    }
+
+    @Test
+    fun testGetHmacFunc_withSha1() {
+        Assert.assertEquals(::hmacSha1, getHmacFunc("sha1"))
+        Assert.assertEquals(::hmacSha1, getHmacFunc("SHA1"))
+    }
+
+    @Test
+    fun testGetHmacFunc_withSha256() {
+        Assert.assertEquals(::hmacSha256, getHmacFunc("sha256"))
+        Assert.assertEquals(::hmacSha256, getHmacFunc("SHA256"))
+    }
+
+    @Test
+    fun testGetHmacFunc_withSha512() {
+        Assert.assertEquals(::hmacSha512, getHmacFunc("sha512"))
+        Assert.assertEquals(::hmacSha512, getHmacFunc("SHA512"))
+    }
+
 }