Scala PublicKey类代码示例

//设置package包名称以及导入依赖的类
package io.scalac.frees.login.handlers.id

import java.security.{PrivateKey, PublicKey}
import java.util.concurrent.TimeUnit

import cats.Id
import io.scalac.frees.login.algebras.{Claims, JwtService}
import io.scalac.frees.login.types.{JWT, UserId}
import pdi.jwt.{Jwt, JwtAlgorithm, JwtCirce, JwtClaim}

import scala.concurrent.duration.FiniteDuration
import scala.util.Try

class IdJwtHandler(
  pubKey: PublicKey,
  privKey: PrivateKey
) extends JwtService.Handler[Id] {
  val twoDays = FiniteDuration(2, TimeUnit.DAYS).toSeconds
  val algo = JwtAlgorithm.ES512

  override def issue(id: UserId): Id[JWT] = {

    val claim = JwtClaim()
      .about(id.toString)
      .issuedNow
      .expiresIn(twoDays)

    Jwt.encode(claim, privKey, algo)
  }

  override def validate(jwt: JWT): Id[Option[Claims]] = {
    JwtCirce.decode(jwt, pubKey, Seq(algo)).toOption.flatMap { c =>
      for {
        userId <- c.subject.flatMap(s => Try(s.toLong).toOption)
        expiration <- c.expiration.filter(_ > currentTimeSeconds)
        issuedAt <- c.issuedAt.filter(_ <= System.currentTimeMillis())
      } yield Claims(userId, issuedAt, expiration)
    }
  }

  private def currentTimeSeconds: Long = System.currentTimeMillis() / 1000

} 

//设置package包名称以及导入依赖的类
package client

import java.security.{Key, PublicKey}
import javax.crypto.{KeyGenerator, Cipher}

import com.cryptoutility.protocol.crypto.{Base64Encode, Encrypt}
import play.api.Configuration

class EncryptionContext (publicKey: PublicKey, config: Configuration) {
  
  val symmetricAlgorithm = config.getString("cipher.symmetric.algorithm").get
  val asymmetricAlgorithm = config.getString("cipher.asymmetric.algorithm").get
  val secretKeyAlgorithm = config.getString("cipher.symmetric.key.algorithm").get

  def encrypt = Encrypt(symmetricAlgorithm, identity)(_, _)

  def cipher = {
    val key = secret
    val c = Cipher.getInstance(symmetricAlgorithm)
    c.init(Cipher.ENCRYPT_MODE, key)
    (key, c)
  }

  def secret = KeyGenerator.getInstance(secretKeyAlgorithm).generateKey()

  def encryptEncoded = Encrypt(symmetricAlgorithm, Base64Encode(_))(_, _)
  def wrap = Encrypt.wrap(asymmetricAlgorithm,  publicKey, Base64Encode(_))(_)
} 

//设置package包名称以及导入依赖的类
package com.github.wildprairie.common.utils

import java.nio.file.Paths
import java.security.{PrivateKey, PublicKey}


object Cipher {
  val RSA = new Cipher("RSA")
}

class Cipher(algorithm: String) {
  import java.nio.file.Files
  import java.security.KeyFactory
  import java.security.spec.X509EncodedKeySpec
  import java.security.spec.PKCS8EncodedKeySpec

  def generatePrivate: PrivateKey = {
    val keyBytes = Files.readAllBytes(Paths.get(getClass.getResource("/private_key.der").toURI))
    val spec = new PKCS8EncodedKeySpec(keyBytes)
    val kf = KeyFactory.getInstance(algorithm)
    kf.generatePrivate(spec)
  }

  def generatePublic: PublicKey = {
    val keyBytes = Files.readAllBytes(Paths.get(getClass.getResource("/public_key.der").toURI))
    val spec = new X509EncodedKeySpec(keyBytes)
    val kf = KeyFactory.getInstance(algorithm)
    kf.generatePublic(spec)
  }

  def decrypt(privateKey: PrivateKey, input: Array[Byte]): Array[Byte] = {
    val decrypt = javax.crypto.Cipher.getInstance(algorithm)
    decrypt.init(javax.crypto.Cipher.DECRYPT_MODE, privateKey)
    decrypt.doFinal(input)
  }
} 

//设置package包名称以及导入依赖的类
package xyztr

import java.security.PublicKey


case class Friend(friendName: String, encodedPublicKeyOfFriend: Array[Byte]) {
  def publicKey = Crypto.getPublicKeyFromEncoded(encodedPublicKeyOfFriend)
}

object Friend {
  def apply(friendName: String, publicKeyOfFriend: PublicKey) = new Friend(friendName, publicKeyOfFriend.getEncoded)
}

case class FriendRequest(nameOfSender: String, encodedPublicKeyOfSender: Array[Byte]) {
  def publicKeyOfSender = Crypto.getPublicKeyFromEncoded(encodedPublicKeyOfSender)
}

object FriendRequest {
  def apply(sender: User) = new FriendRequest(sender.name, sender.publicKey.getEncoded)
}

case class FriendResponse(nameOfSender: Option[String], encodedPublicKeyOfSender: Option[Array[Byte]]) {
  def publicKeyOfSender = encodedPublicKeyOfSender.map(k => Crypto.getPublicKeyFromEncoded(k))
}

object FriendResponse {
  def apply(sender: User): FriendResponse = FriendResponse(Some(sender.name), Some(sender.publicKey.getEncoded))
  def apply(): FriendResponse = new FriendResponse(None, None)    // This is a way of rejecting the friend request
} 

//设置package包名称以及导入依赖的类
package xyztr

import java.security.{PrivateKey, PublicKey}
import java.util.Date
import javax.crypto.SecretKey
import javax.crypto.spec.SecretKeySpec

import xyztr.TierionClient.SaveBubbleRecordResponse


case class BubbleHandle(ipfsHash: String, encodedEncryptedEncryptionKey: Array[Byte], created: Long, blockchainHashId: Option[String]) extends Ordered[BubbleHandle] {
  def decryptSecretKey(privateKey: PrivateKey): SecretKey = new SecretKeySpec(Crypto.decryptWithPrivateKey(encodedEncryptedEncryptionKey, privateKey), "AES")

  def compare(that: BubbleHandle) = {
    val milliDiff = that.created - this.created
    if (milliDiff < 0) -1
    else if (milliDiff > 0) +1
    else 0
  }
}

object BubbleHandle {
  def apply(ipfsHash: String, secretKey: SecretKey, publicKey: PublicKey, response: Option[SaveBubbleRecordResponse] = None): BubbleHandle = response.isDefined match {
    case false => BubbleHandle(ipfsHash, Crypto.encryptWithPublicKey(secretKey.getEncoded, publicKey), new Date().getTime, None)
    case true  => BubbleHandle(ipfsHash, Crypto.encryptWithPublicKey(secretKey.getEncoded, publicKey), response.get.timestamp, Some(response.get.id))
  }
} 

//设置package包名称以及导入依赖的类
package access

import java.security.spec.{ECPoint, ECPublicKeySpec}
import java.security.{KeyFactory, PublicKey, Security}

import com.google.inject.Inject
import org.bouncycastle.jce.ECNamedCurveTable
import org.bouncycastle.jce.spec.ECNamedCurveSpec
import play.api.Configuration

class JWTPublicKeyProviderImpl @Inject()(configuration: Configuration) extends JWTPublicKeyProvider {

  override def publicKey: PublicKey = {
    val xRaw: String = configuration.getString("accessService.X").getOrElse("")
    val yRaw: String = configuration.getString("accessService.Y").getOrElse("")
    val X = BigInt(xRaw, 16)
    val Y = BigInt(yRaw, 16)
    Security.addProvider(new org.bouncycastle.jce.provider.BouncyCastleProvider())
    val curveParams = ECNamedCurveTable.getParameterSpec("P-521")
    val curveSpec =
      new ECNamedCurveSpec("P-521", curveParams.getCurve, curveParams.getG, curveParams.getN, curveParams.getH)
    val publicSpec = new ECPublicKeySpec(new ECPoint(X.underlying(), Y.underlying()), curveSpec)
    KeyFactory.getInstance("ECDSA", "BC").generatePublic(publicSpec)
  }

} 

//设置package包名称以及导入依赖的类
package mu.node.echod.models

import java.security.{PrivateKey, PublicKey}
import java.util.Calendar

import mu.node.echod.util.KeyUtils
import pdi.jwt.Jwt
import play.api.libs.json.Json

import scala.util.Try

case class UserContext(userId: String) extends KeyUtils {

  def toJwt(expiryMillis: Long, jwtSigningKey: PrivateKey): String = {
    val json =
      s"""{
         |  "sub": "$userId",
         |  "exp": $expiryMillis
         |}
         |""".stripMargin
    Jwt.encode(json, jwtSigningKey, jwtDsa)
  }
}

object UserContext extends KeyUtils {
  def fromJwt(jwt: String, jwtVerificationKey: PublicKey): Option[UserContext] = {
    Jwt
      .decode(jwt, jwtVerificationKey, Seq(jwtDsa))
      .flatMap(payload => Try(Json.parse(payload)))
      .toOption
      .filter(json => (json \ "exp").asOpt[Long].exists(notExpired))
      .flatMap(json => (json \ "sub").asOpt[String].map(UserContext(_)))
  }

  private def notExpired(expiryMillis: Long): Boolean =
    expiryMillis > Calendar.getInstance().getTimeInMillis
} 

//设置package包名称以及导入依赖的类
package mu.node.echod.util

import java.nio.file.{Files, Paths}
import java.security.{KeyFactory, PrivateKey, PublicKey}
import java.security.spec.{PKCS8EncodedKeySpec, X509EncodedKeySpec}

import pdi.jwt.JwtAlgorithm.RS256

trait KeyUtils {

  val jwtDsa = RS256

  def loadPkcs8PrivateKey(path: String): PrivateKey = {
    val keyBytes = Files.readAllBytes(Paths.get(path))
    val spec = new PKCS8EncodedKeySpec(keyBytes)
    KeyFactory.getInstance("RSA").generatePrivate(spec)
  }

  def loadX509PublicKey(path: String): PublicKey = {
    val keyBytes = Files.readAllBytes(Paths.get(path))
    val spec = new X509EncodedKeySpec(keyBytes)
    KeyFactory.getInstance("RSA").generatePublic(spec)
  }
} 

//设置package包名称以及导入依赖的类
package mu.node.echod.grpc

import java.security.PublicKey

import com.google.common.collect.Iterables
import io.grpc._
import mu.node.echod.models.UserContext


class UserContextServerInterceptor(jwtVerificationKey: PublicKey) extends ServerInterceptor {

  override def interceptCall[ReqT, RespT](
      call: ServerCall[ReqT, RespT],
      headers: Metadata,
      next: ServerCallHandler[ReqT, RespT]): ServerCall.Listener[ReqT] = {
    readBearerToken(headers) flatMap { token =>
      UserContext.fromJwt(token, jwtVerificationKey)
    } map { userContext =>
      val withUserContext = Context
        .current()
        .withValue[UserContext](UserContextServerInterceptor.userContextKey, userContext)
      Contexts.interceptCall(withUserContext, call, headers, next)
    } getOrElse {
      next.startCall(call, headers)
    }
  }

  private def readBearerToken(headers: Metadata): Option[String] = {
    val authorizationHeaderKey = Metadata.Key.of("Authorization", Metadata.ASCII_STRING_MARSHALLER)
    try {
      Iterables
        .toArray(headers.getAll(authorizationHeaderKey), classOf[String])
        .find(header => header.startsWith("Bearer "))
        .map(header => header.replaceFirst("Bearer ", ""))
    } catch {
      case _: Exception => Option.empty
    }
  }
}

object UserContextServerInterceptor {
  val userContextKey: Context.Key[UserContext] = Context.key("user_context")
} 

//设置package包名称以及导入依赖的类
package gitbucket.core.ssh

import java.security.PublicKey
import java.util.Base64

import org.apache.sshd.common.config.keys.KeyUtils
import org.apache.sshd.common.util.buffer.ByteArrayBuffer
import org.eclipse.jgit.lib.Constants
import org.slf4j.LoggerFactory


object SshUtil {

  private val logger = LoggerFactory.getLogger(SshUtil.getClass)

  def str2PublicKey(key: String): Option[PublicKey] = {
    // TODO RFC 4716 Public Key is not supported...
    val parts = key.split(" ")
    if (parts.size < 2) {
      logger.debug(s"Invalid PublicKey Format: ${key}")
      None
    } else {
      try {
        val encodedKey = parts(1)
        val decode = Base64.getDecoder.decode(Constants.encodeASCII(encodedKey))
        Some(new ByteArrayBuffer(decode).getRawPublicKey)
      } catch {
        case e: Throwable =>
          logger.debug(e.getMessage, e)
          None
      }
    }
  }

  def fingerPrint(key: String): Option[String] =
    str2PublicKey(key) map KeyUtils.getFingerPrint

} 

//设置package包名称以及导入依赖的类
package jwtyped

import java.security.{PrivateKey, PublicKey}
import java.security.spec.PKCS8EncodedKeySpec
import java.util.Base64
import java.security.spec.X509EncodedKeySpec
import java.security.KeyFactory

object PemKeyUtil {

  def decodePublicKey(pem: String): PublicKey = {
    val bytes = pemToDer(pem)
    decodePublicKey(bytes)
  }

  def decodePrivateKey(pem: String): PrivateKey = {
    val bytes = pemToDer(pem)
    decodePrivateKey(bytes)
  }

  def pemToDer(pem: String): Array[Byte] = {
    Base64.getDecoder.decode(trimBeginEnd(pem))
  }

  def trimBeginEnd(pem: String) = {
    pem.replaceAll("-----BEGIN (.*)-----", "")
      .replaceAll("-----END (.*)----", "")
      .replaceAll("\r\n", "")
      .replaceAll("\n", "")
      .trim()
  }

  def decodePublicKey(der: Array[Byte]): PublicKey = {
    val spec = new X509EncodedKeySpec(der)
    val rsa = KeyFactory.getInstance("RSA")
    rsa.generatePublic(spec)
  }

  def decodePrivateKey(der: Array[Byte]): PrivateKey = {
    val spec = new PKCS8EncodedKeySpec(der)
    val rsa = KeyFactory.getInstance("RSA")
    rsa.generatePrivate(spec)
  }

} 

//设置package包名称以及导入依赖的类
package jwtyped.algorithm

import java.security.{PrivateKey, PublicKey}

import jwtyped._

case class AlgoPublicKey(algorithm: String, publicKey: PublicKey)

object AlgoPublicKey {
  implicit val ecdsaVerify = new Verify[AlgoPublicKey] {
    override def verify(algorithm: AlgoPublicKey, message: Message, signature: Signature): Boolean = {
      val ecdsaVerify = java.security.Signature.getInstance(algorithm.algorithm)
      ecdsaVerify.initVerify(algorithm.publicKey)
      ecdsaVerify.update(message.getBytes)
      ecdsaVerify.verify(signature.value)
    }
  }
}

case class AlgoPrivateKey(algorithm: String, privateKey: PrivateKey)

object AlgoPrivateKey {
  implicit val ecdsaSign = new Sign[AlgoPrivateKey] {
    override def sign(algorithm: AlgoPrivateKey, message: Message): Signature = {
      val ecdsaSign = java.security.Signature.getInstance(algorithm.algorithm)
      ecdsaSign.initSign(algorithm.privateKey)
      ecdsaSign.update(message.getBytes)
      Signature(ecdsaSign.sign())
    }
  }
}

case class AlgoPublicPrivateKey(algorithm: String, publicKey: PublicKey, privateKey: PrivateKey)

object AlgoPublicPrivateKey {

  def toAlgoPublicKey(algo: AlgoPublicPrivateKey): AlgoPublicKey = AlgoPublicKey(algo.algorithm, algo.publicKey)

  def toAlgoPrivateKey(algo: AlgoPublicPrivateKey): AlgoPrivateKey = AlgoPrivateKey(algo.algorithm, algo.privateKey)

  implicit val algoPublicPrivateKeySign = new Sign[AlgoPublicPrivateKey] {
    override def sign(algorithm: AlgoPublicPrivateKey, message: Message): Signature = {
      Sign[AlgoPrivateKey].sign(AlgoPublicPrivateKey.toAlgoPrivateKey(algorithm), message)
    }
  }

  implicit val algoPublicPrivateKeyVerify = new Verify[AlgoPublicPrivateKey] {
    override def verify(algorithm: AlgoPublicPrivateKey, message: Message, signature: Signature): Boolean = {
      Verify[AlgoPublicKey].verify(AlgoPublicPrivateKey.toAlgoPublicKey(algorithm), message, signature)
    }
  }
} 

//设置package包名称以及导入依赖的类
package com.eigenroute.authentication

import java.security.spec.{ECPoint, ECPublicKeySpec}
import java.security.{KeyFactory, PublicKey, Security}

import com.typesafe.config.ConfigFactory
import org.bouncycastle.jce.ECNamedCurveTable
import org.bouncycastle.jce.spec.ECNamedCurveSpec

class JWTPublicKeyProviderImpl extends JWTPublicKeyProvider {

  val configuration = ConfigFactory.load()

  override def publicKey: PublicKey = {
    val xRaw: String = configuration.getString("eigenrouteAuthenticatedAction.publicKey.X")
    val yRaw: String = configuration.getString("eigenrouteAuthenticatedAction.publicKey.Y")
    val X = BigInt(xRaw, 16)
    val Y = BigInt(yRaw, 16)
    Security.addProvider(new org.bouncycastle.jce.provider.BouncyCastleProvider())
    val curveParams = ECNamedCurveTable.getParameterSpec("P-521")
    val curveSpec =
      new ECNamedCurveSpec("P-521", curveParams.getCurve, curveParams.getG, curveParams.getN, curveParams.getH)
    val publicSpec = new ECPublicKeySpec(new ECPoint(X.underlying(), Y.underlying()), curveSpec)
    KeyFactory.getInstance("ECDSA", "BC").generatePublic(publicSpec)
  }

}