8907531204

Committed 01 May 2024 09:05AM UTC coverage: 49.271% (-0.3%) from 49.553%

Build Type

push

Committed by

Commit Message

ci: fix scala-steward after moving repo to hyperledger (#993)

Run Details

7 of 29 new or added lines in 3 files covered. (24.14%)

256 existing lines in 78 files now uncovered.

7295 of 14806 relevant lines covered (49.27%)

0.49 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

51.81

/shared/crypto/src/main/scala/org/hyperledger/identus/shared/crypto/KmpApollo.scala

package org.hyperledger.identus.shared.crypto

import io.iohk.atala.prism.apollo.derivation
import io.iohk.atala.prism.apollo.derivation.MnemonicHelper
import io.iohk.atala.prism.apollo.secp256k1.Secp256k1Lib
import io.iohk.atala.prism.apollo.securerandom.SecureRandom
import io.iohk.atala.prism.apollo.utils.KMMECSecp256k1PrivateKey
import io.iohk.atala.prism.apollo.utils.KMMECSecp256k1PublicKey
import io.iohk.atala.prism.apollo.utils.KMMEdKeyPair
import io.iohk.atala.prism.apollo.utils.KMMEdPrivateKey
import io.iohk.atala.prism.apollo.utils.KMMEdPublicKey
import io.iohk.atala.prism.apollo.utils.KMMX25519KeyPair
import io.iohk.atala.prism.apollo.utils.KMMX25519PrivateKey
import io.iohk.atala.prism.apollo.utils.KMMX25519PublicKey
import zio.*

import scala.jdk.CollectionConverters.*
import scala.util.{Try, Success, Failure}

final case class KmpSecp256k1PublicKey(publicKey: KMMECSecp256k1PublicKey) extends Secp256k1PublicKey {

  override def getECPoint: ECPoint = {
    val point = publicKey.getCurvePoint()
    ECPoint(point.getX(), point.getY())
  }

  override def getEncoded: Array[Byte] = publicKey.getCompressed()

  override def getEncodedCompressed: Array[Byte] = getEncoded

  override def getEncodedUncompressed: Array[Byte] =
    KmpSecp256k1KeyOps.secpLib.uncompressPublicKey(getEncodedCompressed)

  override def verify(data: Array[Byte], signature: Array[Byte]): Try[Unit] =
    Try(publicKey.verify(signature, data))
      .flatMap(isValid => if (isValid) Success(()) else Failure(Exception("The signature verification does not match")))
}

final case class KmpSecp256k1PrivateKey(privateKey: KMMECSecp256k1PrivateKey) extends Secp256k1PrivateKey {
  override def sign(data: Array[Byte]): Array[Byte] = privateKey.sign(data)

  override def toPublicKey: Secp256k1PublicKey = KmpSecp256k1PublicKey(privateKey.getPublicKey())

  override def getEncoded: Array[Byte] = privateKey.getEncoded()
}

object KmpSecp256k1KeyOps extends Secp256k1KeyOps {
  private[crypto] val secpLib: Secp256k1Lib = Secp256k1Lib()
  private[crypto] val secureRandom: SecureRandom = SecureRandom()

  override def publicKeyFromEncoded(bytes: Array[Byte]): Try[Secp256k1PublicKey] =
    Try {
      val publicKey = KMMECSecp256k1PublicKey.Companion.secp256k1FromBytes(bytes)
      val point = publicKey.getCurvePoint()
      val isOnCurve = KMMECSecp256k1PublicKey.Companion.isPointOnSecp256k1Curve(point)
      if (isOnCurve) KmpSecp256k1PublicKey(publicKey)
      else throw new Exception("The public key is not on the secp256k1 curve")
    }

  override def publicKeyFromCoordinate(x: Array[Byte], y: Array[Byte]): Try[Secp256k1PublicKey] =
    Try {
      val pk = KMMECSecp256k1PublicKey.Companion.secp256k1FromByteCoordinates(x, y)
      val point = pk.getCurvePoint()
      val isOnCurve = KMMECSecp256k1PublicKey.Companion.isPointOnSecp256k1Curve(point)
      if (isOnCurve) KmpSecp256k1PublicKey(pk)
      else throw Exception("The point is not on the secp256k1 curve")
    }

  override def privateKeyFromEncoded(bytes: Array[Byte]): Try[Secp256k1PrivateKey] =
    Try(KMMECSecp256k1PrivateKey.Companion.secp256k1FromByteArray(bytes)).map(KmpSecp256k1PrivateKey(_))

  override def generateKeyPair: Secp256k1KeyPair = {
    val randBytes = secureRandom.nextBytes(32)
    val privateKey = KMMECSecp256k1PrivateKey(randBytes)
    val publicKey = privateKey.getPublicKey
    Secp256k1KeyPair(
      KmpSecp256k1PublicKey(publicKey),
      KmpSecp256k1PrivateKey(privateKey)
    )
  }

  def randomBip32Seed: UIO[(Array[Byte], Seq[String])] =
    ZIO.attemptBlocking {
      val words = MnemonicHelper.Companion.createRandomMnemonics()
      val seed = MnemonicHelper.Companion.createSeed(words, "")
      seed -> words.asScala.toList
    }.orDie

  def deriveKeyPair(seed: Array[Byte])(path: DerivationPath*): UIO[Secp256k1KeyPair] =
    ZIO.attemptBlocking {
      val pathStr = path
        .foldLeft(derivation.DerivationPath.empty()) { case (path, p) =>
          p match {
            case DerivationPath.Hardened(i) => path.derive(derivation.DerivationAxis.hardened(i))
            case DerivationPath.Normal(i)   => path.derive(derivation.DerivationAxis.normal(i))
          }
        }
        .toString()
      val hdKey = derivation.HDKey(seed, 0, 0).derive(pathStr)
      val privateKey = hdKey.getKMMSecp256k1PrivateKey()
      val publicKey = privateKey.getPublicKey()

      Secp256k1KeyPair(
        KmpSecp256k1PublicKey(publicKey),
        KmpSecp256k1PrivateKey(privateKey)
      )
    }.orDie

}

final case class KmpEd25519PublicKey(publicKey: KMMEdPublicKey) extends Ed25519PublicKey {
  override def getEncoded: Array[Byte] = publicKey.getRaw()
  override def verify(data: Array[Byte], signature: Array[Byte]): Try[Unit] =
    Try(publicKey.verify(data, signature))
      .flatMap(isValid => if (isValid) Success(()) else Failure(Exception("The signature verification does not match")))
}

final case class KmpEd25519PrivateKey(privateKey: KMMEdPrivateKey) extends Ed25519PrivateKey {
  override def getEncoded: Array[Byte] = privateKey.getRaw()
  override def sign(data: Array[Byte]): Array[Byte] = privateKey.sign(data)
  override def toPublicKey: Ed25519PublicKey = KmpEd25519PublicKey(privateKey.publicKey())
}

object KmpEd25519KeyOps extends Ed25519KeyOps {

  override def publicKeyFromEncoded(bytes: Array[Byte]): Try[Ed25519PublicKey] =
    Try {
      if bytes.length != 32 then throw Exception("Invalid public key length")
      KmpEd25519PublicKey(KMMEdPublicKey(bytes))
    }

  override def privateKeyFromEncoded(bytes: Array[Byte]): Try[Ed25519PrivateKey] =
    Try {
      if bytes.length != 32 then throw Exception("Invalid private key length")
      KmpEd25519PrivateKey(KMMEdPrivateKey(bytes))
    }

  override def generateKeyPair: Ed25519KeyPair = {
    val keyPair = KMMEdKeyPair.Companion.generateKeyPair()
    Ed25519KeyPair(
      KmpEd25519PublicKey(keyPair.getPublicKey()),
      KmpEd25519PrivateKey(keyPair.getPrivateKey())
    )
  }

}

final case class KmpX25519PublicKey(publicKey: KMMX25519PublicKey) extends X25519PublicKey {
  override def getEncoded: Array[Byte] = publicKey.getRaw()
}

final case class KmpX25519PrivateKey(privateKey: KMMX25519PrivateKey) extends X25519PrivateKey {
  override def getEncoded: Array[Byte] = privateKey.getRaw()
  override def toPublicKey: X25519PublicKey = KmpX25519PublicKey(privateKey.publicKey())
}

object KmpX25519KeyOps extends X25519KeyOps {
  override def publicKeyFromEncoded(bytes: Array[Byte]): Try[X25519PublicKey] =
    Try {
      if bytes.length != 32 then throw Exception("Invalid public key length")
      KmpX25519PublicKey(KMMX25519PublicKey(bytes))
    }

  override def privateKeyFromEncoded(bytes: Array[Byte]): Try[X25519PrivateKey] =
    Try {
      if bytes.length != 32 then throw Exception("Invalid private key length")
      KmpX25519PrivateKey(KMMX25519PrivateKey(bytes))
    }

  override def generateKeyPair: X25519KeyPair = {
    val keyPair = KMMX25519KeyPair.Companion.generateKeyPair()
    X25519KeyPair(
      KmpX25519PublicKey(keyPair.getPublicKey()),
      KmpX25519PrivateKey(keyPair.getPrivateKey())
    )
  }
}

1	package org.hyperledger.identus.shared.crypto
2
3	import io.iohk.atala.prism.apollo.derivation
4	import io.iohk.atala.prism.apollo.derivation.MnemonicHelper
5	import io.iohk.atala.prism.apollo.secp256k1.Secp256k1Lib
6	import io.iohk.atala.prism.apollo.securerandom.SecureRandom
7	import io.iohk.atala.prism.apollo.utils.KMMECSecp256k1PrivateKey
8	import io.iohk.atala.prism.apollo.utils.KMMECSecp256k1PublicKey
9	import io.iohk.atala.prism.apollo.utils.KMMEdKeyPair
10	import io.iohk.atala.prism.apollo.utils.KMMEdPrivateKey
11	import io.iohk.atala.prism.apollo.utils.KMMEdPublicKey
12	import io.iohk.atala.prism.apollo.utils.KMMX25519KeyPair
13	import io.iohk.atala.prism.apollo.utils.KMMX25519PrivateKey
14	import io.iohk.atala.prism.apollo.utils.KMMX25519PublicKey
15	import zio.*
16
17	import scala.jdk.CollectionConverters.*
18	import scala.util.{Try, Success, Failure}
19
20	final case class KmpSecp256k1PublicKey(publicKey: KMMECSecp256k1PublicKey) extends Secp256k1PublicKey {
21
22	override def getECPoint: ECPoint = {	1✔
23	val point = publicKey.getCurvePoint()	1✔
24	ECPoint(point.getX(), point.getY())	1✔
25	}
26
27	override def getEncoded: Array[Byte] = publicKey.getCompressed()	1✔
28
29	override def getEncodedCompressed: Array[Byte] = getEncoded	1✔
30
31	override def getEncodedUncompressed: Array[Byte] =	×
32	KmpSecp256k1KeyOps.secpLib.uncompressPublicKey(getEncodedCompressed)	×
33
34	override def verify(data: Array[Byte], signature: Array[Byte]): Try[Unit] =	1✔
35	Try(publicKey.verify(signature, data))	1✔
UNCOV 36	.flatMap(isValid => if (isValid) Success(()) else Failure(Exception("The signature verification does not match")))	×
37	}
38
39	final case class KmpSecp256k1PrivateKey(privateKey: KMMECSecp256k1PrivateKey) extends Secp256k1PrivateKey {
40	override def sign(data: Array[Byte]): Array[Byte] = privateKey.sign(data)	1✔
41
42	override def toPublicKey: Secp256k1PublicKey = KmpSecp256k1PublicKey(privateKey.getPublicKey())	1✔
43
44	override def getEncoded: Array[Byte] = privateKey.getEncoded()	1✔
45	}
46
47	object KmpSecp256k1KeyOps extends Secp256k1KeyOps {
48	private[crypto] val secpLib: Secp256k1Lib = Secp256k1Lib()	1✔
49	private[crypto] val secureRandom: SecureRandom = SecureRandom()	1✔
50
51	override def publicKeyFromEncoded(bytes: Array[Byte]): Try[Secp256k1PublicKey] =	1✔
52	Try {	1✔
53	val publicKey = KMMECSecp256k1PublicKey.Companion.secp256k1FromBytes(bytes)	1✔
54	val point = publicKey.getCurvePoint()	1✔
55	val isOnCurve = KMMECSecp256k1PublicKey.Companion.isPointOnSecp256k1Curve(point)	1✔
56	if (isOnCurve) KmpSecp256k1PublicKey(publicKey)	1✔
57	else throw new Exception("The public key is not on the secp256k1 curve")	×
58	}
59
60	override def publicKeyFromCoordinate(x: Array[Byte], y: Array[Byte]): Try[Secp256k1PublicKey] =	1✔
61	Try {	1✔
62	val pk = KMMECSecp256k1PublicKey.Companion.secp256k1FromByteCoordinates(x, y)	1✔
63	val point = pk.getCurvePoint()	1✔
64	val isOnCurve = KMMECSecp256k1PublicKey.Companion.isPointOnSecp256k1Curve(point)	1✔
65	if (isOnCurve) KmpSecp256k1PublicKey(pk)	1✔
66	else throw Exception("The point is not on the secp256k1 curve")	×
67	}
68
69	override def privateKeyFromEncoded(bytes: Array[Byte]): Try[Secp256k1PrivateKey] =	1✔
70	Try(KMMECSecp256k1PrivateKey.Companion.secp256k1FromByteArray(bytes)).map(KmpSecp256k1PrivateKey(_))	1✔
71
72	override def generateKeyPair: Secp256k1KeyPair = {	1✔
73	val randBytes = secureRandom.nextBytes(32)	1✔
74	val privateKey = KMMECSecp256k1PrivateKey(randBytes)	1✔
75	val publicKey = privateKey.getPublicKey	1✔
76	Secp256k1KeyPair(
77	KmpSecp256k1PublicKey(publicKey),
78	KmpSecp256k1PrivateKey(privateKey)
79	)
80	}
81
82	def randomBip32Seed: UIO[(Array[Byte], Seq[String])] =	1✔
83	ZIO.attemptBlocking {	1✔
84	val words = MnemonicHelper.Companion.createRandomMnemonics()	1✔
85	val seed = MnemonicHelper.Companion.createSeed(words, "")	1✔
86	seed -> words.asScala.toList	1✔
87	}.orDie
88
89	def deriveKeyPair(seed: Array[Byte])(path: DerivationPath*): UIO[Secp256k1KeyPair] =	1✔
90	ZIO.attemptBlocking {	1✔
91	val pathStr = path
92	.foldLeft(derivation.DerivationPath.empty()) { case (path, p) =>	1✔
93	p match {
94	case DerivationPath.Hardened(i) => path.derive(derivation.DerivationAxis.hardened(i))	1✔
95	case DerivationPath.Normal(i) => path.derive(derivation.DerivationAxis.normal(i))	×
96	}
97	}
98	.toString()	1✔
99	val hdKey = derivation.HDKey(seed, 0, 0).derive(pathStr)	1✔
100	val privateKey = hdKey.getKMMSecp256k1PrivateKey()	1✔
101	val publicKey = privateKey.getPublicKey()	1✔
102
103	Secp256k1KeyPair(
104	KmpSecp256k1PublicKey(publicKey),
105	KmpSecp256k1PrivateKey(privateKey)
106	)
107	}.orDie
108
109	}
110
111	final case class KmpEd25519PublicKey(publicKey: KMMEdPublicKey) extends Ed25519PublicKey {
112	override def getEncoded: Array[Byte] = publicKey.getRaw()	×
113	override def verify(data: Array[Byte], signature: Array[Byte]): Try[Unit] =	×
114	Try(publicKey.verify(data, signature))	×
115	.flatMap(isValid => if (isValid) Success(()) else Failure(Exception("The signature verification does not match")))	×
116	}
117
118	final case class KmpEd25519PrivateKey(privateKey: KMMEdPrivateKey) extends Ed25519PrivateKey {
119	override def getEncoded: Array[Byte] = privateKey.getRaw()	×
120	override def sign(data: Array[Byte]): Array[Byte] = privateKey.sign(data)	×
121	override def toPublicKey: Ed25519PublicKey = KmpEd25519PublicKey(privateKey.publicKey())	×
122	}
123
124	object KmpEd25519KeyOps extends Ed25519KeyOps {
125
126	override def publicKeyFromEncoded(bytes: Array[Byte]): Try[Ed25519PublicKey] =	×
127	Try {	×
128	if bytes.length != 32 then throw Exception("Invalid public key length")	×
129	KmpEd25519PublicKey(KMMEdPublicKey(bytes))	×
130	}
131
132	override def privateKeyFromEncoded(bytes: Array[Byte]): Try[Ed25519PrivateKey] =	×
133	Try {	×
134	if bytes.length != 32 then throw Exception("Invalid private key length")	×
135	KmpEd25519PrivateKey(KMMEdPrivateKey(bytes))	×
136	}
137
138	override def generateKeyPair: Ed25519KeyPair = {	×
139	val keyPair = KMMEdKeyPair.Companion.generateKeyPair()	×
140	Ed25519KeyPair(
141	KmpEd25519PublicKey(keyPair.getPublicKey()),	×
142	KmpEd25519PrivateKey(keyPair.getPrivateKey())	×
143	)
144	}
145
146	}
147
148	final case class KmpX25519PublicKey(publicKey: KMMX25519PublicKey) extends X25519PublicKey {
149	override def getEncoded: Array[Byte] = publicKey.getRaw()	×
150	}
151
152	final case class KmpX25519PrivateKey(privateKey: KMMX25519PrivateKey) extends X25519PrivateKey {
153	override def getEncoded: Array[Byte] = privateKey.getRaw()	×
154	override def toPublicKey: X25519PublicKey = KmpX25519PublicKey(privateKey.publicKey())	×
155	}
156
157	object KmpX25519KeyOps extends X25519KeyOps {
158	override def publicKeyFromEncoded(bytes: Array[Byte]): Try[X25519PublicKey] =	×
159	Try {	×
160	if bytes.length != 32 then throw Exception("Invalid public key length")	×
161	KmpX25519PublicKey(KMMX25519PublicKey(bytes))	×
162	}
163
164	override def privateKeyFromEncoded(bytes: Array[Byte]): Try[X25519PrivateKey] =	×
165	Try {	×
166	if bytes.length != 32 then throw Exception("Invalid private key length")	×
167	KmpX25519PrivateKey(KMMX25519PrivateKey(bytes))	×
168	}
169
170	override def generateKeyPair: X25519KeyPair = {	×
171	val keyPair = KMMX25519KeyPair.Companion.generateKeyPair()	×
172	X25519KeyPair(
173	KmpX25519PublicKey(keyPair.getPublicKey()),	×
174	KmpX25519PrivateKey(keyPair.getPrivateKey())	×
175	)
176	}
177	}

input-output-hk / atala-prism-building-blocks / 8907531204

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous