elliptic curve point in homogeneous coordinates (X,Y,Z) to access affine coordinates, normalize the point. the point at infinity cannot be normalized.

ECPointSerializer

object ECPointSerializer : KSerializer<ECPoint.Normalized>

EncryptedPrivateKey

class EncryptedPrivateKey(val encryptionAlgorithm: ObjectIdentifier, val encryptedData: ByteArray) : PemEncodable<Asn1Sequence>

Representation of an encrypted private key structure as per RFC 5208

IosHomebrewAttestation

@Serializable

@SerialName(value = "ios-appattest")

data class IosHomebrewAttestation(val attestation: ByteArray, val clientDataJSON: ByteArray) : Attestation

RSAPadding

enum RSAPadding : Enum<RSAPadding>

SelfAttestation

@Serializable

@SerialName(value = "self")

data class SelfAttestation(val certificate: X509Certificate) : Attestation

SignatureAlgorithm

sealed interface SignatureAlgorithm

SpecializedCryptoPublicKey

interface SpecializedCryptoPublicKey

SpecializedSignatureAlgorithm

interface SpecializedSignatureAlgorithm

X509SignatureAlgorithm

@Serializable(with = X509SignatureAlgorithmSerializer::class)

enum X509SignatureAlgorithm : Enum<X509SignatureAlgorithm> , Asn1Encodable<Asn1Sequence> , Identifiable, SpecializedSignatureAlgorithm

X509SignatureAlgorithmSerializer

object X509SignatureAlgorithmSerializer : KSerializer<X509SignatureAlgorithm>

Properties

iosEncoded

val CryptoSignature.iosEncoded: ByteArray

iosEncodedPrivateKeyLength

val ECCurve.iosEncodedPrivateKeyLength: Int

Returns the length of a private key, when it is exported from iOS. This is handy, because Apple does not encode curve identifiers, but implies them based on the length of the key

iosEncodedPublicKeyLength

val ECCurve.iosEncodedPublicKeyLength: Int

Returns the length of a public key, when it is exported from iOS. This is handy, because Apple does not encode curve identifiers, but implies them based on the length of the key

jcaAlgorithmComponent

val Digest?.jcaAlgorithmComponent: String

jcaName

val Digest.jcaName: String

val ECCurve.jcaName: String

jcaPSSParams

val Digest.jcaPSSParams: PSSParameterSpec

jcaSignatureBytes

val CryptoSignature.jcaSignatureBytes: ByteArray

In Java EC signatures are returned as DER-encoded, RSA signatures however are raw bytearrays

jsonEncoded

val Attestation.jsonEncoded: String

nativeDigest

val ECCurve.nativeDigest: Digest

A digest well-suited to operations on this curve, with output length near the curve's coordinate length.

secKeyAlgorithm

val SignatureAlgorithm.secKeyAlgorithm: SecKeyAlgorithm

val SpecializedSignatureAlgorithm.secKeyAlgorithm: CPointer<__CFString>

secKeyAlgorithmPreHashed

val SignatureAlgorithm.secKeyAlgorithmPreHashed: SecKeyAlgorithm

val SpecializedSignatureAlgorithm.secKeyAlgorithmPreHashed: CPointer<__CFString>

StrictJson

val StrictJson: Json

Functions

byJcaName

fun ECCurve.Companion.byJcaName(name: String): ECCurve?

ceilDiv

inline fun UInt.ceilDiv(other: UInt): UInt

contentEqualsIfArray

infix inline fun <T> Any.contentEqualsIfArray(other: T): Boolean

contentHashCodeIfArray

inline fun Any.contentHashCodeIfArray(): Int

equalsCryptographically

fun CryptoPublicKey.equalsCryptographically(other: CryptoPublicKey): Boolean

Alias of equals provided for convenience (and alignment with SpecializedCryptoPublicKey)

fun CryptoPublicKey.equalsCryptographically(other: SpecializedCryptoPublicKey): Boolean

fun SpecializedCryptoPublicKey.equalsCryptographically(other: CryptoPublicKey): Boolean

fun SpecializedCryptoPublicKey.equalsCryptographically(other: SpecializedCryptoPublicKey): Boolean

Whether the actual underlying key (irrespective of any format-specific metadata) is equal

fromIosEncodedPrivateKeyLength

fun ECCurve.Companion.fromIosEncodedPrivateKeyLength(length: Int): ECCurve?

Returns the curve associated with a public key exported from iOS based on the length of the key material This is handy, because Apple does not encode curve identifiers, but implies them based on the length of the key

fromIosEncodedPublicKeyLength

fun ECCurve.Companion.fromIosEncodedPublicKeyLength(length: Int): ECCurve?

fromJcaPublicKey

fun CryptoPublicKey.Companion.~~fromJcaPublicKey~~(publicKey: PublicKey): KmmResult<CryptoPublicKey>

fun CryptoPublicKey.EC.Companion.~~fromJcaPublicKey~~(publicKey: ECPublicKey): KmmResult<CryptoPublicKey.EC>

fun CryptoPublicKey.RSA.Companion.~~fromJcaPublicKey~~(publicKey: RSAPublicKey): KmmResult<CryptoPublicKey.RSA>

getJcaPublicKey

fun CryptoPublicKey.~~getJcaPublicKey~~(): KmmResult<PublicKey>

fun CryptoPublicKey.EC.~~getJcaPublicKey~~(): KmmResult<ECPublicKey>

fun CryptoPublicKey.RSA.~~getJcaPublicKey~~(): KmmResult<RSAPublicKey>

getJCASignatureInstance

fun SignatureAlgorithm.getJCASignatureInstance(provider: String? = null): KmmResult<Signature>

fun SpecializedSignatureAlgorithm.getJCASignatureInstance(provider: String? = null): KmmResult<Signature>

Get a pre-configured JCA instance for this algorithm

getJCASignatureInstancePreHashed

fun SignatureAlgorithm.getJCASignatureInstancePreHashed(provider: String? = null): KmmResult<Signature>

fun SpecializedSignatureAlgorithm.getJCASignatureInstancePreHashed(provider: String? = null): KmmResult<Signature>

Get a pre-configured JCA instance for pre-hashed data for this algorithm

parseFromJca

fun CryptoSignature.EC.Companion.parseFromJca(input: ByteArray): CryptoSignature.EC.IndefiniteLength

Parses a signature produced by the JCA digestwithECDSA algorithm.

fun CryptoSignature.RSAorHMAC.Companion.parseFromJca(input: ByteArray): CryptoSignature.RSAorHMAC

fun CryptoSignature.Companion.parseFromJca(input: ByteArray, algorithm: SpecializedSignatureAlgorithm): CryptoSignature

fun CryptoSignature.Companion.parseFromJca(input: ByteArray, algorithm: SignatureAlgorithm): CryptoSignature

In Java EC signatures are returned as DER-encoded, RSA signatures however are raw bytearrays

parseFromJcaP1363

fun CryptoSignature.EC.Companion.parseFromJcaP1363(input: ByteArray): CryptoSignature.EC.DefiniteLength

Parses a signature produced by the JCA digestWithECDSAinP1363Format algorithm.

toCryptoPrivateKey

fun PrivateKey.toCryptoPrivateKey(): KmmResult<CryptoPrivateKey.WithPublicKey<*>>

fun ECPrivateKey.toCryptoPrivateKey(): KmmResult<CryptoPrivateKey.EC.WithPublicKey>

fun RSAPrivateKey.toCryptoPrivateKey(): KmmResult<CryptoPrivateKey.RSA>

toCryptoPublicKey

fun PublicKey.toCryptoPublicKey(): KmmResult<CryptoPublicKey>

fun ECPublicKey.toCryptoPublicKey(): KmmResult<CryptoPublicKey.EC>

fun RSAPublicKey.toCryptoPublicKey(): KmmResult<CryptoPublicKey.RSA>

toJcaCertificate

suspend fun X509Certificate.toJcaCertificate(): KmmResult<X509Certificate>

Converts this X509Certificate to a java.security.cert.X509Certificate. This function is suspending, because it uses a mutex to lock the underlying certificate factory (which is reused for performance reasons

toJcaCertificateBlocking