internal data class PrivateKeyInfo(
  // v1(0), v2(1).
  val version: Long,
  val algorithmIdentifier: AlgorithmIdentifier,
  val privateKey: ByteString,
) {
  // Avoid Long.hashCode(long) which isn't available on Android 5.
  override fun hashCode(): Int {
    var result = 0
    result = 31 * result + version.toInt()
    result = 31 * result + algorithmIdentifier.hashCode()
    result = 31 * result + privateKey.hashCode()
    return result

        else -> null
      }
    }

  /**
   * ```
   * AlgorithmIdentifier ::= SEQUENCE  {
   *   algorithm      OBJECT IDENTIFIER,
   *   parameters     ANY DEFINED BY algorithm OPTIONAL
   * }
   * ```
   */
  internal val algorithmIdentifier: BasicDerAdapter<AlgorithmIdentifier> =
    Adapters.sequence(
      "AlgorithmIdentifier",
      Adapters.OBJECT_IDENTIFIER.asTypeHint(),
      algorithmParameters,

      ).decodeBase64()!!

    val decoded = CertificateAdapters.privateKeyInfo.fromDer(privateKeyInfoByteString)

    assertThat(decoded.version).isEqualTo(0L)
    assertThat(decoded.algorithmIdentifier).isEqualTo(AlgorithmIdentifier(RSA_ENCRYPTION, null))
    assertThat(decoded.privateKey.size).isEqualTo(607)

    val encoded = CertificateAdapters.privateKeyInfo.toDer(decoded)

    val algorithmIdentifier =
      AlgorithmIdentifier(
        algorithm = SHA256_WITH_RSA_ENCRYPTION,
        parameters = null,
      )
    assertThat(CertificateAdapters.algorithmIdentifier.fromDer(bytes))
      .isEqualTo(algorithmIdentifier)
    assertThat(CertificateAdapters.algorithmIdentifier.toDer(algorithmIdentifier))
      .isEqualTo(bytes)
  }

    }

    private fun signatureAlgorithm(signedByKeyPair: KeyPair): AlgorithmIdentifier =
      when (signedByKeyPair.private) {
        is RSAPrivateKey ->
          AlgorithmIdentifier(
            algorithm = SHA256_WITH_RSA_ENCRYPTION,
            parameters = null,
          )
        else ->
          AlgorithmIdentifier(
            algorithm = SHA256_WITH_ECDSA,
            parameters = ByteString.EMPTY,

pkg crypto/x509/pkix, method (Name) ToRDNSequence() RDNSequence
pkg crypto/x509/pkix, type AlgorithmIdentifier struct
pkg crypto/x509/pkix, type AlgorithmIdentifier struct, Algorithm asn1.ObjectIdentifier
pkg crypto/x509/pkix, type AlgorithmIdentifier struct, Parameters asn1.RawValue
pkg crypto/x509/pkix, type AttributeTypeAndValue struct

840, 1, 101, 3, 4, 2, 8}, crypto.SHA3_384: {2, 16, 840, 1, 101, 3, 4, 2, 9}, crypto.SHA3_512: {2, 16, 840, 1, 101, 3, 4, 2, 10}, } for h, oid := range prefixes { want, err := asn1.Marshal(struct { HashAlgorithm pkix.AlgorithmIdentifier Hash []byte }{ HashAlgorithm: pkix.AlgorithmIdentifier{ Algorithm: oid, Parameters: asn1.NullRawValue, }, Hash: make([]byte, h.Size()), }) if err != nil { t.Fatal(err) } want = want[:len(want)-h.Size()] got := hashPrefixes[h.String()] if !bytes.Equal(got, want) { t.Errorf("%s:...