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

63.64

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

package org.hyperledger.identus.shared.crypto

import com.nimbusds.jose.jwk.OctetKeyPair
import com.nimbusds.jose.util.Base64URL
import org.bouncycastle.asn1.x509.SubjectPublicKeyInfo
import org.bouncycastle.crypto.params.Ed25519PublicKeyParameters
import org.bouncycastle.crypto.util.SubjectPublicKeyInfoFactory
import org.bouncycastle.jce.provider.BouncyCastleProvider
import org.bouncycastle.jce.spec.ECNamedCurveSpec
import org.bouncycastle.jce.ECNamedCurveTable
import org.hyperledger.identus.shared.models.HexString
import zio.*

import java.security.{KeyFactory, PublicKey}
import java.security.interfaces.EdECPublicKey
import java.security.spec.*
import scala.util.Try

trait Apollo {
  def secp256k1: Secp256k1KeyOps
  def ed25519: Ed25519KeyOps
  def x25519: X25519KeyOps
}

object Apollo {
  def layer: ULayer[Apollo] = ZLayer.succeed(default)

  def default: Apollo = new {
    override def secp256k1: Secp256k1KeyOps = KmpSecp256k1KeyOps
    override def ed25519: Ed25519KeyOps = KmpEd25519KeyOps
    override def x25519: X25519KeyOps = KmpX25519KeyOps
  }
}

trait Encodable {
  def getEncoded: Array[Byte]
}

trait Signable {
  def sign(data: Array[Byte]): Array[Byte]
}

trait Verifiable {
  def verify(data: Array[Byte], signature: Array[Byte]): Try[Unit]
}

trait PublicKey extends Encodable
trait PrivateKey extends Encodable {
  type Pub <: PublicKey
  def toPublicKey: Pub
  override final def toString(): String = "<REDACTED>"
}

enum DerivationPath {
  case Normal(i: Int) extends DerivationPath
  case Hardened(i: Int) extends DerivationPath
}

final case class ECPoint(x: Array[Byte], y: Array[Byte])

final case class EdECPoint(x: Boolean, y: Array[Byte])

// secp256k1
final case class Secp256k1KeyPair(publicKey: Secp256k1PublicKey, privateKey: Secp256k1PrivateKey)
trait Secp256k1PublicKey extends PublicKey, Verifiable {
  def getEncodedCompressed: Array[Byte]

  def getEncodedUncompressed: Array[Byte]

  def getECPoint: ECPoint

  override final def hashCode(): Int = HexString.fromByteArray(getEncoded).hashCode()

  override final def equals(x: Any): Boolean = x match {
    case otherPK: Secp256k1PublicKey =>
      HexString.fromByteArray(this.getEncoded) == HexString.fromByteArray(otherPK.getEncoded)
    case _ => false
  }

  def toJavaPublicKey: java.security.interfaces.ECPublicKey = {
    val point = getECPoint
    val x = BigInt(1, point.x)
    val y = BigInt(1, point.y)
    val keyFactory = KeyFactory.getInstance("EC", new BouncyCastleProvider())
    val ecParameterSpec = ECNamedCurveTable.getParameterSpec("secp256k1")
    val ecNamedCurveSpec = ECNamedCurveSpec(
      ecParameterSpec.getName(),
      ecParameterSpec.getCurve(),
      ecParameterSpec.getG(),
      ecParameterSpec.getN()
    )
    val ecPublicKeySpec = ECPublicKeySpec(java.security.spec.ECPoint(x.bigInteger, y.bigInteger), ecNamedCurveSpec)
    keyFactory.generatePublic(ecPublicKeySpec).asInstanceOf[java.security.interfaces.ECPublicKey]
  }
}
trait Secp256k1PrivateKey extends PrivateKey, Signable {
  type Pub = Secp256k1PublicKey

  override final def hashCode(): Int = HexString.fromByteArray(getEncoded).hashCode()

  override final def equals(x: Any): Boolean = x match {
    case otherPK: Secp256k1PrivateKey =>
      HexString.fromByteArray(this.getEncoded) == HexString.fromByteArray(otherPK.getEncoded)
    case _ => false
  }

  def toJavaPrivateKey: java.security.interfaces.ECPrivateKey = {
    val bytes = getEncoded
    val keyFactory = KeyFactory.getInstance("EC", new BouncyCastleProvider())
    val ecParameterSpec = ECNamedCurveTable.getParameterSpec("secp256k1")
    val ecNamedCurveSpec = ECNamedCurveSpec(
      ecParameterSpec.getName(),
      ecParameterSpec.getCurve(),
      ecParameterSpec.getG(),
      ecParameterSpec.getN()
    )
    val ecPrivateKeySpec = ECPrivateKeySpec(java.math.BigInteger(1, bytes), ecNamedCurveSpec)
    keyFactory.generatePrivate(ecPrivateKeySpec).asInstanceOf[java.security.interfaces.ECPrivateKey]
  }
}
trait Secp256k1KeyOps {
  def publicKeyFromEncoded(bytes: Array[Byte]): Try[Secp256k1PublicKey]
  def publicKeyFromCoordinate(x: Array[Byte], y: Array[Byte]): Try[Secp256k1PublicKey]
  def privateKeyFromEncoded(bytes: Array[Byte]): Try[Secp256k1PrivateKey]
  def generateKeyPair: Secp256k1KeyPair
  def randomBip32Seed: UIO[(Array[Byte], Seq[String])]
  def deriveKeyPair(seed: Array[Byte])(path: DerivationPath*): UIO[Secp256k1KeyPair]
}

// ed25519
final case class Ed25519KeyPair(publicKey: Ed25519PublicKey, privateKey: Ed25519PrivateKey) {
  def toOctetKeyPair: OctetKeyPair = {
    val d = java.util.Base64.getUrlEncoder.withoutPadding().encodeToString(privateKey.getEncoded)
    val x = java.util.Base64.getUrlEncoder.withoutPadding().encodeToString(publicKey.getEncoded)
    val okpJson = s"""{"kty":"OKP","crv":"Ed25519","d":"$d","x":"$x"}"""
    OctetKeyPair.parse(okpJson)
  }
}
object Ed25519PublicKey {

  def toJavaEd25519PublicKey(rawPublicKeyBytes: Array[Byte]): java.security.PublicKey = {
    val publicKeyParams = new Ed25519PublicKeyParameters(rawPublicKeyBytes, 0)
    val subjectPublicKeyInfo = SubjectPublicKeyInfoFactory.createSubjectPublicKeyInfo(publicKeyParams)
    val publicKeyInfoBytes = subjectPublicKeyInfo.getEncoded
    val keyFactory = KeyFactory.getInstance("Ed25519", "BC")
    val x509PublicKeySpec = new java.security.spec.X509EncodedKeySpec(publicKeyInfoBytes)
    keyFactory.generatePublic(x509PublicKeySpec)
  }
  def toPublicKeyOctetKeyPair(publicKey: EdECPublicKey): OctetKeyPair = {
    val subjectPublicKeyInfo = SubjectPublicKeyInfo.getInstance(publicKey.getEncoded)
    val x = Base64URL.encode(subjectPublicKeyInfo.getPublicKeyData.getBytes)
    val okpJson = s"""{"kty":"OKP","crv":"Ed25519","x":"$x"}"""
    OctetKeyPair.parse(okpJson)
  }

}
trait Ed25519PublicKey extends PublicKey, Verifiable {
  override final def hashCode(): Int = HexString.fromByteArray(getEncoded).hashCode()

  override final def equals(x: Any): Boolean = x match {
    case otherPK: Ed25519PublicKey =>
      HexString.fromByteArray(this.getEncoded) == HexString.fromByteArray(otherPK.getEncoded)
    case _ => false
  }

}
trait Ed25519PrivateKey extends PrivateKey, Signable {
  type Pub = Ed25519PublicKey

  override final def hashCode(): Int = HexString.fromByteArray(getEncoded).hashCode()

  override final def equals(x: Any): Boolean = x match {
    case otherPK: Ed25519PrivateKey =>
      HexString.fromByteArray(this.getEncoded) == HexString.fromByteArray(otherPK.getEncoded)
    case _ => false
  }
}
trait Ed25519KeyOps {
  def publicKeyFromEncoded(bytes: Array[Byte]): Try[Ed25519PublicKey]
  def privateKeyFromEncoded(bytes: Array[Byte]): Try[Ed25519PrivateKey]
  def generateKeyPair: Ed25519KeyPair
}

// x25519
final case class X25519KeyPair(publicKey: X25519PublicKey, privateKey: X25519PrivateKey)
trait X25519PublicKey extends PublicKey {
  override final def hashCode(): Int = HexString.fromByteArray(getEncoded).hashCode()

  override final def equals(x: Any): Boolean = x match {
    case otherPK: X25519PublicKey =>
      HexString.fromByteArray(this.getEncoded) == HexString.fromByteArray(otherPK.getEncoded)
    case _ => false
  }
}
trait X25519PrivateKey extends PrivateKey {
  type Pub = X25519PublicKey

  override final def hashCode(): Int = HexString.fromByteArray(getEncoded).hashCode()

  override final def equals(x: Any): Boolean = x match {
    case otherPK: X25519PrivateKey =>
      HexString.fromByteArray(this.getEncoded) == HexString.fromByteArray(otherPK.getEncoded)
    case _ => false
  }
}
trait X25519KeyOps {
  def publicKeyFromEncoded(bytes: Array[Byte]): Try[X25519PublicKey]
  def privateKeyFromEncoded(bytes: Array[Byte]): Try[X25519PrivateKey]
  def generateKeyPair: X25519KeyPair
}

1	package org.hyperledger.identus.shared.crypto
2
3	import com.nimbusds.jose.jwk.OctetKeyPair
4	import com.nimbusds.jose.util.Base64URL
5	import org.bouncycastle.asn1.x509.SubjectPublicKeyInfo
6	import org.bouncycastle.crypto.params.Ed25519PublicKeyParameters
7	import org.bouncycastle.crypto.util.SubjectPublicKeyInfoFactory
8	import org.bouncycastle.jce.provider.BouncyCastleProvider
9	import org.bouncycastle.jce.spec.ECNamedCurveSpec
10	import org.bouncycastle.jce.ECNamedCurveTable
11	import org.hyperledger.identus.shared.models.HexString
12	import zio.*
13
14	import java.security.{KeyFactory, PublicKey}
15	import java.security.interfaces.EdECPublicKey
16	import java.security.spec.*
17	import scala.util.Try
18
19	trait Apollo {
20	def secp256k1: Secp256k1KeyOps
21	def ed25519: Ed25519KeyOps
22	def x25519: X25519KeyOps
23	}
24
25	object Apollo {
26	def layer: ULayer[Apollo] = ZLayer.succeed(default)	1✔
27
28	def default: Apollo = new {	1✔
29	override def secp256k1: Secp256k1KeyOps = KmpSecp256k1KeyOps	1✔
30	override def ed25519: Ed25519KeyOps = KmpEd25519KeyOps	1✔
31	override def x25519: X25519KeyOps = KmpX25519KeyOps	1✔
32	}
33	}
34
35	trait Encodable {
36	def getEncoded: Array[Byte]
37	}
38
39	trait Signable {
40	def sign(data: Array[Byte]): Array[Byte]
41	}
42
43	trait Verifiable {
44	def verify(data: Array[Byte], signature: Array[Byte]): Try[Unit]
45	}
46
47	trait PublicKey extends Encodable
48	trait PrivateKey extends Encodable {
49	type Pub <: PublicKey
50	def toPublicKey: Pub
51	override final def toString(): String = "<REDACTED>"	×
52	}
53
54	enum DerivationPath {
55	case Normal(i: Int) extends DerivationPath
56	case Hardened(i: Int) extends DerivationPath
57	}
58
59	final case class ECPoint(x: Array[Byte], y: Array[Byte])
60
61	final case class EdECPoint(x: Boolean, y: Array[Byte])
62
63	// secp256k1
64	final case class Secp256k1KeyPair(publicKey: Secp256k1PublicKey, privateKey: Secp256k1PrivateKey)
65	trait Secp256k1PublicKey extends PublicKey, Verifiable {
66	def getEncodedCompressed: Array[Byte]
67
68	def getEncodedUncompressed: Array[Byte]
69
70	def getECPoint: ECPoint
71
72	override final def hashCode(): Int = HexString.fromByteArray(getEncoded).hashCode()	1✔
73
74	override final def equals(x: Any): Boolean = x match {	1✔
75	case otherPK: Secp256k1PublicKey =>	1✔
76	HexString.fromByteArray(this.getEncoded) == HexString.fromByteArray(otherPK.getEncoded)	1✔
77	case _ => false	×
78	}
79
80	def toJavaPublicKey: java.security.interfaces.ECPublicKey = {	1✔
81	val point = getECPoint	1✔
82	val x = BigInt(1, point.x)	1✔
83	val y = BigInt(1, point.y)	1✔
84	val keyFactory = KeyFactory.getInstance("EC", new BouncyCastleProvider())	1✔
85	val ecParameterSpec = ECNamedCurveTable.getParameterSpec("secp256k1")	1✔
86	val ecNamedCurveSpec = ECNamedCurveSpec(	1✔
87	ecParameterSpec.getName(),	1✔
88	ecParameterSpec.getCurve(),	1✔
89	ecParameterSpec.getG(),	1✔
90	ecParameterSpec.getN()	1✔
91	)
92	val ecPublicKeySpec = ECPublicKeySpec(java.security.spec.ECPoint(x.bigInteger, y.bigInteger), ecNamedCurveSpec)	1✔
93	keyFactory.generatePublic(ecPublicKeySpec).asInstanceOf[java.security.interfaces.ECPublicKey]	1✔
94	}
95	}
96	trait Secp256k1PrivateKey extends PrivateKey, Signable {
97	type Pub = Secp256k1PublicKey
98
99	override final def hashCode(): Int = HexString.fromByteArray(getEncoded).hashCode()	1✔
100
101	override final def equals(x: Any): Boolean = x match {	1✔
102	case otherPK: Secp256k1PrivateKey =>	1✔
103	HexString.fromByteArray(this.getEncoded) == HexString.fromByteArray(otherPK.getEncoded)	1✔
104	case _ => false	×
105	}
106
107	def toJavaPrivateKey: java.security.interfaces.ECPrivateKey = {	1✔
108	val bytes = getEncoded	1✔
109	val keyFactory = KeyFactory.getInstance("EC", new BouncyCastleProvider())	1✔
110	val ecParameterSpec = ECNamedCurveTable.getParameterSpec("secp256k1")	1✔
111	val ecNamedCurveSpec = ECNamedCurveSpec(	1✔
112	ecParameterSpec.getName(),	1✔
113	ecParameterSpec.getCurve(),	1✔
114	ecParameterSpec.getG(),	1✔
115	ecParameterSpec.getN()	1✔
116	)
117	val ecPrivateKeySpec = ECPrivateKeySpec(java.math.BigInteger(1, bytes), ecNamedCurveSpec)	1✔
118	keyFactory.generatePrivate(ecPrivateKeySpec).asInstanceOf[java.security.interfaces.ECPrivateKey]	1✔
119	}
120	}
121	trait Secp256k1KeyOps {
122	def publicKeyFromEncoded(bytes: Array[Byte]): Try[Secp256k1PublicKey]
123	def publicKeyFromCoordinate(x: Array[Byte], y: Array[Byte]): Try[Secp256k1PublicKey]
124	def privateKeyFromEncoded(bytes: Array[Byte]): Try[Secp256k1PrivateKey]
125	def generateKeyPair: Secp256k1KeyPair
126	def randomBip32Seed: UIO[(Array[Byte], Seq[String])]
127	def deriveKeyPair(seed: Array[Byte])(path: DerivationPath*): UIO[Secp256k1KeyPair]
128	}
129
130	// ed25519
131	final case class Ed25519KeyPair(publicKey: Ed25519PublicKey, privateKey: Ed25519PrivateKey) {
132	def toOctetKeyPair: OctetKeyPair = {	×
133	val d = java.util.Base64.getUrlEncoder.withoutPadding().encodeToString(privateKey.getEncoded)	×
134	val x = java.util.Base64.getUrlEncoder.withoutPadding().encodeToString(publicKey.getEncoded)	×
135	val okpJson = s"""{"kty":"OKP","crv":"Ed25519","d":"$d","x":"$x"}"""	×
136	OctetKeyPair.parse(okpJson)	×
137	}
138	}
139	object Ed25519PublicKey {
140
141	def toJavaEd25519PublicKey(rawPublicKeyBytes: Array[Byte]): java.security.PublicKey = {	×
142	val publicKeyParams = new Ed25519PublicKeyParameters(rawPublicKeyBytes, 0)	×
143	val subjectPublicKeyInfo = SubjectPublicKeyInfoFactory.createSubjectPublicKeyInfo(publicKeyParams)	×
144	val publicKeyInfoBytes = subjectPublicKeyInfo.getEncoded	×
145	val keyFactory = KeyFactory.getInstance("Ed25519", "BC")	×
146	val x509PublicKeySpec = new java.security.spec.X509EncodedKeySpec(publicKeyInfoBytes)	×
147	keyFactory.generatePublic(x509PublicKeySpec)	×
148	}
149	def toPublicKeyOctetKeyPair(publicKey: EdECPublicKey): OctetKeyPair = {	×
150	val subjectPublicKeyInfo = SubjectPublicKeyInfo.getInstance(publicKey.getEncoded)	×
151	val x = Base64URL.encode(subjectPublicKeyInfo.getPublicKeyData.getBytes)	×
152	val okpJson = s"""{"kty":"OKP","crv":"Ed25519","x":"$x"}"""	×
153	OctetKeyPair.parse(okpJson)	×
154	}
155
156	}
157	trait Ed25519PublicKey extends PublicKey, Verifiable {
158	override final def hashCode(): Int = HexString.fromByteArray(getEncoded).hashCode()	×
159
160	override final def equals(x: Any): Boolean = x match {	1✔
161	case otherPK: Ed25519PublicKey =>	1✔
162	HexString.fromByteArray(this.getEncoded) == HexString.fromByteArray(otherPK.getEncoded)	1✔
163	case _ => false	×
164	}
165
166	}
167	trait Ed25519PrivateKey extends PrivateKey, Signable {
168	type Pub = Ed25519PublicKey
169
170	override final def hashCode(): Int = HexString.fromByteArray(getEncoded).hashCode()	×
171
172	override final def equals(x: Any): Boolean = x match {	1✔
173	case otherPK: Ed25519PrivateKey =>	1✔
174	HexString.fromByteArray(this.getEncoded) == HexString.fromByteArray(otherPK.getEncoded)	1✔
175	case _ => false	×
176	}
177	}
178	trait Ed25519KeyOps {
179	def publicKeyFromEncoded(bytes: Array[Byte]): Try[Ed25519PublicKey]
180	def privateKeyFromEncoded(bytes: Array[Byte]): Try[Ed25519PrivateKey]
181	def generateKeyPair: Ed25519KeyPair
182	}
183
184	// x25519
185	final case class X25519KeyPair(publicKey: X25519PublicKey, privateKey: X25519PrivateKey)
186	trait X25519PublicKey extends PublicKey {
187	override final def hashCode(): Int = HexString.fromByteArray(getEncoded).hashCode()	×
188
189	override final def equals(x: Any): Boolean = x match {	1✔
190	case otherPK: X25519PublicKey =>	1✔
191	HexString.fromByteArray(this.getEncoded) == HexString.fromByteArray(otherPK.getEncoded)	1✔
192	case _ => false	×
193	}
194	}
195	trait X25519PrivateKey extends PrivateKey {
196	type Pub = X25519PublicKey
197
198	override final def hashCode(): Int = HexString.fromByteArray(getEncoded).hashCode()	×
199
200	override final def equals(x: Any): Boolean = x match {	1✔
201	case otherPK: X25519PrivateKey =>	1✔
202	HexString.fromByteArray(this.getEncoded) == HexString.fromByteArray(otherPK.getEncoded)	1✔
203	case _ => false	×
204	}
205	}
206	trait X25519KeyOps {
207	def publicKeyFromEncoded(bytes: Array[Byte]): Try[X25519PublicKey]
208	def privateKeyFromEncoded(bytes: Array[Byte]): Try[X25519PrivateKey]
209	def generateKeyPair: X25519KeyPair
210	}

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