Throw ISE instead of custom exception for now

whyoleg · whyoleg · commit 01e0ea6c4d8d · 2024-10-09T18:58:12.000+03:00
diff --git a/cryptography-core/src/commonMain/kotlin/CryptographyAlgorithmNotFoundException.kt b/cryptography-core/src/commonMain/kotlin/CryptographyAlgorithmNotFoundException.kt
@@ -1,9 +1,14 @@
 /*
- * Copyright (c) 2023 Oleg Yukhnevich. Use of this source code is governed by the Apache 2.0 license.
+ * Copyright (c) 2023-2024 Oleg Yukhnevich. Use of this source code is governed by the Apache 2.0 license.
  */
 
 package dev.whyoleg.cryptography
 
+@Suppress("DEPRECATION_ERROR")
+@Deprecated(
+    "IllegalStateException is throw instead",
+    level = DeprecationLevel.ERROR
+)
 public class CryptographyAlgorithmNotFoundException(
     algorithm: CryptographyAlgorithmId<*>,
 ) : CryptographyException("Algorithm not found: $algorithm")
diff --git a/cryptography-core/src/commonMain/kotlin/CryptographyException.kt b/cryptography-core/src/commonMain/kotlin/CryptographyException.kt
@@ -1,9 +1,13 @@
 /*
- * Copyright (c) 2023 Oleg Yukhnevich. Use of this source code is governed by the Apache 2.0 license.
+ * Copyright (c) 2023-2024 Oleg Yukhnevich. Use of this source code is governed by the Apache 2.0 license.
  */
 
 package dev.whyoleg.cryptography
 
+@Deprecated(
+    "IllegalStateException is throw instead",
+    level = DeprecationLevel.ERROR
+)
 public open class CryptographyException : RuntimeException {
     public constructor(message: String?) : super(message)
     public constructor(message: String?, cause: Throwable?) : super(message, cause)
diff --git a/cryptography-core/src/commonMain/kotlin/CryptographyProvider.kt b/cryptography-core/src/commonMain/kotlin/CryptographyProvider.kt
@@ -10,7 +10,7 @@ public abstract class CryptographyProvider {
 
     public abstract fun <A : CryptographyAlgorithm> getOrNull(identifier: CryptographyAlgorithmId<A>): A?
     public open fun <A : CryptographyAlgorithm> get(identifier: CryptographyAlgorithmId<A>): A =
-        getOrNull(identifier) ?: throw CryptographyAlgorithmNotFoundException(identifier)
+        getOrNull(identifier) ?: throw IllegalStateException("Algorithm not found: $identifier")
 
     @CryptographyProviderApi
     public object Registry {
diff --git a/cryptography-providers/apple/src/commonMain/kotlin/algorithms/CCHmac.kt b/cryptography-providers/apple/src/commonMain/kotlin/algorithms/CCHmac.kt
@@ -22,7 +22,7 @@ internal object CCHmac : HMAC {
             SHA256 -> HmacKeyDecoder(kCCHmacAlgSHA256, CC_SHA256_BLOCK_BYTES, CC_SHA256_DIGEST_LENGTH)
             SHA384 -> HmacKeyDecoder(kCCHmacAlgSHA384, CC_SHA384_BLOCK_BYTES, CC_SHA384_DIGEST_LENGTH)
             SHA512 -> HmacKeyDecoder(kCCHmacAlgSHA512, CC_SHA512_BLOCK_BYTES, CC_SHA512_DIGEST_LENGTH)
-            else   -> throw CryptographyException("Unsupported hash algorithm: $digest")
+            else -> throw IllegalStateException("Unsupported hash algorithm: $digest")
         }
     }
 
@@ -33,7 +33,7 @@ internal object CCHmac : HMAC {
             SHA256 -> HmacKeyGenerator(kCCHmacAlgSHA256, CC_SHA256_BLOCK_BYTES, CC_SHA256_DIGEST_LENGTH)
             SHA384 -> HmacKeyGenerator(kCCHmacAlgSHA384, CC_SHA384_BLOCK_BYTES, CC_SHA384_DIGEST_LENGTH)
             SHA512 -> HmacKeyGenerator(kCCHmacAlgSHA512, CC_SHA512_BLOCK_BYTES, CC_SHA512_DIGEST_LENGTH)
-            else   -> throw CryptographyException("Unsupported hash algorithm: $digest")
+            else -> throw IllegalStateException("Unsupported hash algorithm: $digest")
         }
     }
 }
diff --git a/cryptography-providers/apple/src/commonMain/kotlin/internal/digest.kt b/cryptography-providers/apple/src/commonMain/kotlin/internal/digest.kt
@@ -15,7 +15,7 @@ internal fun CryptographyAlgorithmId<Digest>.rsaPssSecKeyAlgorithm(): SecKeyAlgo
     SHA256 -> kSecKeyAlgorithmRSASignatureMessagePSSSHA256
     SHA384 -> kSecKeyAlgorithmRSASignatureMessagePSSSHA384
     SHA512 -> kSecKeyAlgorithmRSASignatureMessagePSSSHA512
-    else   -> throw CryptographyException("Unsupported hash algorithm: $this")
+    else -> throw IllegalStateException("Unsupported hash algorithm: $this")
 }
 
 internal fun CryptographyAlgorithmId<Digest>.rsaPkcs1SecKeyAlgorithm(): SecKeyAlgorithm? = when (this) {
@@ -24,7 +24,7 @@ internal fun CryptographyAlgorithmId<Digest>.rsaPkcs1SecKeyAlgorithm(): SecKeyAl
     SHA256 -> kSecKeyAlgorithmRSASignatureMessagePKCS1v15SHA256
     SHA384 -> kSecKeyAlgorithmRSASignatureMessagePKCS1v15SHA384
     SHA512 -> kSecKeyAlgorithmRSASignatureMessagePKCS1v15SHA512
-    else   -> throw CryptographyException("Unsupported hash algorithm: $this")
+    else -> throw IllegalStateException("Unsupported hash algorithm: $this")
 }
 
 internal fun CryptographyAlgorithmId<Digest>.rsaOaepSecKeyAlgorithm(): SecKeyAlgorithm? = when (this) {
@@ -33,7 +33,7 @@ internal fun CryptographyAlgorithmId<Digest>.rsaOaepSecKeyAlgorithm(): SecKeyAlg
     SHA256 -> kSecKeyAlgorithmRSAEncryptionOAEPSHA256
     SHA384 -> kSecKeyAlgorithmRSAEncryptionOAEPSHA384
     SHA512 -> kSecKeyAlgorithmRSAEncryptionOAEPSHA512
-    else   -> throw CryptographyException("Unsupported hash algorithm: $this")
+    else -> throw IllegalStateException("Unsupported hash algorithm: $this")
 }
 
 internal fun CryptographyAlgorithmId<Digest>.ecdsaSecKeyAlgorithm(): SecKeyAlgorithm? = when (this) {
@@ -42,7 +42,7 @@ internal fun CryptographyAlgorithmId<Digest>.ecdsaSecKeyAlgorithm(): SecKeyAlgor
     SHA256 -> kSecKeyAlgorithmECDSASignatureMessageX962SHA256
     SHA384 -> kSecKeyAlgorithmECDSASignatureMessageX962SHA384
     SHA512 -> kSecKeyAlgorithmECDSASignatureMessageX962SHA512
-    else   -> throw CryptographyException("Unsupported hash algorithm: $this")
+    else -> throw IllegalStateException("Unsupported hash algorithm: $this")
 }
 
 internal fun CryptographyAlgorithmId<Digest>.pbkdh2Algorithm(): CCPseudoRandomAlgorithm = when (this) {
@@ -51,5 +51,5 @@ internal fun CryptographyAlgorithmId<Digest>.pbkdh2Algorithm(): CCPseudoRandomAl
     SHA256 -> kCCPRFHmacAlgSHA256
     SHA384 -> kCCPRFHmacAlgSHA384
     SHA512 -> kCCPRFHmacAlgSHA512
-    else   -> throw CryptographyException("Unsupported hash algorithm: $this")
+    else -> throw IllegalStateException("Unsupported hash algorithm: $this")
 }
diff --git a/cryptography-providers/jdk/src/jvmMain/kotlin/JdkCryptographyState.kt b/cryptography-providers/jdk/src/jvmMain/kotlin/JdkCryptographyState.kt
@@ -91,5 +91,5 @@ internal fun CryptographyAlgorithmId<Digest>.hashAlgorithmName(): String = when
     SHA3_256 -> "SHA3-256"
     SHA3_384 -> "SHA3-384"
     SHA3_512 -> "SHA3-512"
-    else     -> throw CryptographyException("Unsupported hash algorithm: $this")
+    else -> throw IllegalStateException("Unsupported hash algorithm: $this")
 }
diff --git a/cryptography-providers/jdk/src/jvmMain/kotlin/algorithms/JdkHmac.kt b/cryptography-providers/jdk/src/jvmMain/kotlin/algorithms/JdkHmac.kt
@@ -50,5 +50,5 @@ private fun CryptographyAlgorithmId<Digest>.blockSize(): Int = when (this) {
     SHA3_256 -> 136
     SHA3_384 -> 104
     SHA3_512 -> 72
-    else     -> throw CryptographyException("Unsupported hash algorithm: $this")
+    else -> throw IllegalStateException("Unsupported hash algorithm: $this")
 } * 8
diff --git a/cryptography-providers/jdk/src/jvmMain/kotlin/algorithms/JdkRsa.kt b/cryptography-providers/jdk/src/jvmMain/kotlin/algorithms/JdkRsa.kt
@@ -23,7 +23,7 @@ internal fun CryptographyAlgorithmId<Digest>.rsaHashAlgorithmName(): String = wh
     SHA3_256 -> "SHA3-256"
     SHA3_384 -> "SHA3-384"
     SHA3_512 -> "SHA3-512"
-    else     -> throw CryptographyException("Unsupported hash algorithm: $this")
+    else -> throw IllegalStateException("Unsupported hash algorithm: $this")
 }
 
 internal abstract class RsaPublicKeyDecoder<K : RSA.PublicKey>(
diff --git a/cryptography-providers/openssl3/api/src/commonMain/kotlin/internal/errors.kt b/cryptography-providers/openssl3/api/src/commonMain/kotlin/internal/errors.kt
@@ -1,10 +1,9 @@
 /*
- * Copyright (c) 2023 Oleg Yukhnevich. Use of this source code is governed by the Apache 2.0 license.
+ * Copyright (c) 2023-2024 Oleg Yukhnevich. Use of this source code is governed by the Apache 2.0 license.
  */
 
 package dev.whyoleg.cryptography.providers.openssl3.internal
 
-import dev.whyoleg.cryptography.*
 import dev.whyoleg.cryptography.providers.openssl3.internal.cinterop.*
 import kotlinx.cinterop.*
 import platform.posix.*
@@ -39,5 +38,5 @@ private fun fail(result: Int): Nothing {
             if (code.toInt() != 0) append(", ")
         } while (code.toInt() != 0)
     }
-    throw CryptographyException("OPENSSL failure: $message (result: $result)")
+    throw IllegalStateException("OPENSSL failure: $message (result: $result)")
 }
diff --git a/cryptography-providers/openssl3/api/src/commonMain/kotlin/internal/hash.kt b/cryptography-providers/openssl3/api/src/commonMain/kotlin/internal/hash.kt
@@ -17,5 +17,5 @@ internal fun hashAlgorithm(digest: CryptographyAlgorithmId<Digest>): String = wh
     SHA3_256 -> "SHA3-256"
     SHA3_384 -> "SHA3-384"
     SHA3_512 -> "SHA3-512"
-    else     -> throw CryptographyException("Unsupported hash algorithm: $digest")
+    else -> throw IllegalStateException("Unsupported hash algorithm: $digest")
 }
diff --git a/cryptography-providers/webcrypto/src/commonMain/kotlin/internal/digest.kt b/cryptography-providers/webcrypto/src/commonMain/kotlin/internal/digest.kt
@@ -12,21 +12,21 @@ internal fun CryptographyAlgorithmId<Digest>.blockSize(): Int = when (this) {
     SHA256 -> 64
     SHA384 -> 128
     SHA512 -> 128
-    else   -> throw CryptographyException("Unsupported hash algorithm: $this")
+    else -> throw IllegalStateException("Unsupported hash algorithm: $this")
 } * 8
 
 internal fun CryptographyAlgorithmId<Digest>.hashAlgorithmName(): String = when (this) {
     SHA1   -> "SHA-1"
     SHA256 -> "SHA-256"
     SHA384 -> "SHA-384"
     SHA512 -> "SHA-512"
-    else   -> throw CryptographyException("Unsupported hash algorithm: ${this}")
+    else -> throw IllegalStateException("Unsupported hash algorithm: ${this}")
 }
 
 internal fun hashSize(hashAlgorithmName: String): Int = when (hashAlgorithmName) {
     "SHA-1"   -> 20
     "SHA-256" -> 32
     "SHA-384" -> 48
     "SHA-512" -> 64
-    else      -> throw CryptographyException("Unsupported hash algorithm: $hashAlgorithmName")
+    else -> throw IllegalStateException("Unsupported hash algorithm: $hashAlgorithmName")
 }
diff --git a/cryptography-providers/webcrypto/src/commonMain/kotlin/internal/utils.kt b/cryptography-providers/webcrypto/src/commonMain/kotlin/internal/utils.kt
@@ -4,6 +4,4 @@
 
 package dev.whyoleg.cryptography.providers.webcrypto.internal
 
-import dev.whyoleg.cryptography.*
-
-internal fun nonBlocking(): Nothing = throw CryptographyException("Only non-blocking(suspend) calls are supported in WebCrypto")
+internal fun nonBlocking(): Nothing = throw IllegalStateException("Only non-blocking(suspend) calls are supported in WebCrypto")

Original file line number	Diff line number	Diff line change
`@@ -22,7 +22,7 @@ internal object CCHmac : HMAC {`
`22`	`22`	`SHA256 -> HmacKeyDecoder(kCCHmacAlgSHA256, CC_SHA256_BLOCK_BYTES, CC_SHA256_DIGEST_LENGTH)`
`23`	`23`	`SHA384 -> HmacKeyDecoder(kCCHmacAlgSHA384, CC_SHA384_BLOCK_BYTES, CC_SHA384_DIGEST_LENGTH)`
`24`	`24`	`SHA512 -> HmacKeyDecoder(kCCHmacAlgSHA512, CC_SHA512_BLOCK_BYTES, CC_SHA512_DIGEST_LENGTH)`
`25`		`- else -> throw CryptographyException("Unsupported hash algorithm: $digest")`
	`25`	`+ else -> throw IllegalStateException("Unsupported hash algorithm: $digest")`
`26`	`26`	`}`
`27`	`27`	`}`
`28`	`28`
`@@ -33,7 +33,7 @@ internal object CCHmac : HMAC {`
`33`	`33`	`SHA256 -> HmacKeyGenerator(kCCHmacAlgSHA256, CC_SHA256_BLOCK_BYTES, CC_SHA256_DIGEST_LENGTH)`
`34`	`34`	`SHA384 -> HmacKeyGenerator(kCCHmacAlgSHA384, CC_SHA384_BLOCK_BYTES, CC_SHA384_DIGEST_LENGTH)`
`35`	`35`	`SHA512 -> HmacKeyGenerator(kCCHmacAlgSHA512, CC_SHA512_BLOCK_BYTES, CC_SHA512_DIGEST_LENGTH)`
`36`		`- else -> throw CryptographyException("Unsupported hash algorithm: $digest")`
	`36`	`+ else -> throw IllegalStateException("Unsupported hash algorithm: $digest")`
`37`	`37`	`}`
`38`	`38`	`}`
`39`	`39`	`}`
Original file line number	Diff line number	Diff line change
`@@ -91,5 +91,5 @@ internal fun CryptographyAlgorithmId<Digest>.hashAlgorithmName(): String = when`
`91`	`91`	`SHA3_256 -> "SHA3-256"`
`92`	`92`	`SHA3_384 -> "SHA3-384"`
`93`	`93`	`SHA3_512 -> "SHA3-512"`
`94`		`- else -> throw CryptographyException("Unsupported hash algorithm: $this")`
	`94`	`+ else -> throw IllegalStateException("Unsupported hash algorithm: $this")`
`95`	`95`	`}`
Original file line number	Diff line number	Diff line change
`@@ -23,7 +23,7 @@ internal fun CryptographyAlgorithmId<Digest>.rsaHashAlgorithmName(): String = wh`
`23`	`23`	`SHA3_256 -> "SHA3-256"`
`24`	`24`	`SHA3_384 -> "SHA3-384"`
`25`	`25`	`SHA3_512 -> "SHA3-512"`
`26`		`- else -> throw CryptographyException("Unsupported hash algorithm: $this")`
	`26`	`+ else -> throw IllegalStateException("Unsupported hash algorithm: $this")`
`27`	`27`	`}`
`28`	`28`
`29`	`29`	`internal abstract class RsaPublicKeyDecoder<K : RSA.PublicKey>(`
Original file line number	Diff line number	Diff line change
`@@ -17,5 +17,5 @@ internal fun hashAlgorithm(digest: CryptographyAlgorithmId<Digest>): String = wh`
`17`	`17`	`SHA3_256 -> "SHA3-256"`
`18`	`18`	`SHA3_384 -> "SHA3-384"`
`19`	`19`	`SHA3_512 -> "SHA3-512"`
`20`		`- else -> throw CryptographyException("Unsupported hash algorithm: $digest")`
	`20`	`+ else -> throw IllegalStateException("Unsupported hash algorithm: $digest")`
`21`	`21`	`}`