10793991050

Committed 10 Sep 2024 01:56PM CUT coverage: 48.504% (-4.5%) from 52.962%

Build Type

push

Committed by

Commit Message

build: sbt and plugins dependency update (#1337)

Signed-off-by: Hyperledger Bot <hyperledger-bot@hyperledger.org>
Signed-off-by: Yurii Shynbuiev <yurii.shynbuiev@iohk.io>
Co-authored-by: Hyperledger Bot <hyperledger-bot@hyperledger.org>
Co-authored-by: Yurii Shynbuiev <yurii.shynbuiev@iohk.io>

Run Details

7406 of 15269 relevant lines covered (48.5%)

0.49 hits per line

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

78.31

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

package org.hyperledger.identus.shared.crypto

import org.hyperledger.identus.apollo.derivation
import org.hyperledger.identus.apollo.derivation.MnemonicHelper
import org.hyperledger.identus.apollo.secp256k1.Secp256k1Lib
import org.hyperledger.identus.apollo.securerandom.SecureRandom
import org.hyperledger.identus.apollo.utils.{
  KMMECSecp256k1PrivateKey,
  KMMECSecp256k1PublicKey,
  KMMEdKeyPair,
  KMMEdPrivateKey,
  KMMEdPublicKey,
  KMMX25519KeyPair,
  KMMX25519PrivateKey,
  KMMX25519PublicKey
}
import zio.*

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

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

hyperledger / identus-cloud-agent / 10793991050

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