path: root/openpgp-ktx/src/main/java/org/openintents/openpgp/OpenPgpSignatureResult.kt

/*
 * Copyright © 2014-2021 The Android Password Store Authors. All Rights Reserved.
 * SPDX-License-Identifier: GPL-3.0-only
 */
@file:JvmName("OpenPgpSignatureResult")

package org.openintents.openpgp

import android.os.Parcel
import android.os.Parcelable
import android.os.Parcelable.Creator
import java.util.Date
import me.msfjarvis.openpgpktx.util.OpenPgpUtils

public class OpenPgpSignatureResult : Parcelable {

    private val result: Int
    private val keyId: Long
    private val primaryUserId: String?
    private val userIds: ArrayList<String>?
    private val confirmedUserIds: ArrayList<String>?
    private val senderStatusResult: SenderStatusResult?
    private val signatureTimestamp: Date?
    private val autocryptPeerentityResult: AutocryptPeerResult?

    private constructor(
        signatureStatus: Int,
        signatureUserId: String?,
        keyId: Long,
        userIds: ArrayList<String>?,
        confirmedUserIds: ArrayList<String>?,
        senderStatusResult: SenderStatusResult?,
        signatureOnly: Boolean?,
        signatureTimestamp: Date?,
        autocryptPeerentityResult: AutocryptPeerResult?
    ) {
        result = signatureStatus
        primaryUserId = signatureUserId
        this.keyId = keyId
        this.userIds = userIds
        this.confirmedUserIds = confirmedUserIds
        this.senderStatusResult = senderStatusResult
        this.signatureTimestamp = signatureTimestamp
        this.autocryptPeerentityResult = autocryptPeerentityResult
    }

    private constructor(source: Parcel, version: Int) {
        result = source.readInt()
        // we dropped support for signatureOnly, but need to skip the value for compatibility
        source.readByte()
        primaryUserId = source.readString()
        keyId = source.readLong()
        userIds = if (version > 1) {
            source.createStringArrayList()
        } else {
            null
        }
        // backward compatibility for this exact version
        if (version > 2) {
            senderStatusResult = readEnumWithNullAndFallback(
                source,
                SenderStatusResult.values(),
                SenderStatusResult.UNKNOWN
            )
            confirmedUserIds = source.createStringArrayList()
        } else {
            senderStatusResult = SenderStatusResult.UNKNOWN
            confirmedUserIds = null
        }
        signatureTimestamp = if (version > 3) {
            if (source.readInt() > 0) Date(source.readLong()) else null
        } else {
            null
        }
        autocryptPeerentityResult = if (version > 4) {
            readEnumWithNullAndFallback(
                source,
                AutocryptPeerResult.values(),
                null
            )
        } else {
            null
        }
    }

    public fun getUserIds(): List<String> {
        return (userIds ?: arrayListOf()).toList()
    }

    public fun getConfirmedUserIds(): List<String> {
        return (confirmedUserIds ?: arrayListOf()).toList()
    }

    override fun describeContents(): Int {
        return 0
    }

    override fun writeToParcel(dest: Parcel, flags: Int) {
        /**
         * NOTE: When adding fields in the process of updating this API, make sure to bump
         * [.PARCELABLE_VERSION].
         */
        dest.writeInt(PARCELABLE_VERSION)
        // Inject a placeholder that will store the parcel size from this point on
        // (not including the size itself).
        val sizePosition = dest.dataPosition()
        dest.writeInt(0)
        val startPosition = dest.dataPosition()
        // version 1
        dest.writeInt(result)
        // signatureOnly is deprecated since version 3. we pass a dummy value for compatibility
        dest.writeByte(0.toByte())
        dest.writeString(primaryUserId)
        dest.writeLong(keyId)
        // version 2
        dest.writeStringList(userIds)
        // version 3
        writeEnumWithNull(dest, senderStatusResult)
        dest.writeStringList(confirmedUserIds)
        // version 4
        if (signatureTimestamp != null) {
            dest.writeInt(1)
            dest.writeLong(signatureTimestamp.time)
        } else {
            dest.writeInt(0)
        }
        // version 5
        writeEnumWithNull(dest, autocryptPeerentityResult)
        // Go back and write the size
        val parcelableSize = dest.dataPosition() - startPosition
        dest.setDataPosition(sizePosition)
        dest.writeInt(parcelableSize)
        dest.setDataPosition(startPosition + parcelableSize)
    }

    override fun toString(): String {
        var out = "\nresult: $result"
        out += "\nprimaryUserId: $primaryUserId"
        out += "\nuserIds: $userIds"
        out += "\nkeyId: " + OpenPgpUtils.convertKeyIdToHex(keyId)
        return out
    }

    @Deprecated("")
    public fun withSignatureOnlyFlag(signatureOnly: Boolean): OpenPgpSignatureResult {
        return OpenPgpSignatureResult(
            result, primaryUserId, keyId, userIds, confirmedUserIds,
            senderStatusResult, signatureOnly, signatureTimestamp, autocryptPeerentityResult
        )
    }

    public fun withAutocryptPeerResult(autocryptPeerentityResult: AutocryptPeerResult?): OpenPgpSignatureResult {
        return OpenPgpSignatureResult(
            result, primaryUserId, keyId, userIds, confirmedUserIds,
            senderStatusResult, null, signatureTimestamp, autocryptPeerentityResult
        )
    }

    public enum class SenderStatusResult {
        UNKNOWN, USER_ID_CONFIRMED, USER_ID_UNCONFIRMED, USER_ID_MISSING;
    }

    public enum class AutocryptPeerResult {
        OK, NEW, MISMATCH;
    }

    public companion object CREATOR : Creator<OpenPgpSignatureResult> {

        /**
         * Since there might be a case where new versions of the client using the library getting
         * old versions of the protocol (and thus old versions of this class), we need a versioning
         * system for the parcels sent between the clients and the providers.
         */
        private const val PARCELABLE_VERSION = 5

        // content not signed
        public const val RESULT_NO_SIGNATURE: Int = -1

        // invalid signature!
        public const val RESULT_INVALID_SIGNATURE: Int = 0

        // successfully verified signature, with confirmed key
        public const val RESULT_VALID_KEY_CONFIRMED: Int = 1

        // no key was found for this signature verification
        public const val RESULT_KEY_MISSING: Int = 2

        // successfully verified signature, but with unconfirmed key
        public const val RESULT_VALID_KEY_UNCONFIRMED: Int = 3

        // key has been revoked -> invalid signature!
        public const val RESULT_INVALID_KEY_REVOKED: Int = 4

        // key is expired -> invalid signature!
        public const val RESULT_INVALID_KEY_EXPIRED: Int = 5

        // insecure cryptographic algorithms/protocol -> invalid signature!
        public const val RESULT_INVALID_KEY_INSECURE: Int = 6

        override fun createFromParcel(source: Parcel): OpenPgpSignatureResult? {
            val version = source.readInt() // parcelableVersion
            val parcelableSize = source.readInt()
            val startPosition = source.dataPosition()
            val vr = OpenPgpSignatureResult(source, version)
            // skip over all fields added in future versions of this parcel
            source.setDataPosition(startPosition + parcelableSize)
            return vr
        }

        override fun newArray(size: Int): Array<OpenPgpSignatureResult?> {
            return arrayOfNulls(size)
        }

        public fun createWithValidSignature(
            signatureStatus: Int,
            primaryUserId: String?,
            keyId: Long,
            userIds: ArrayList<String>?,
            confirmedUserIds: ArrayList<String>?,
            senderStatusResult: SenderStatusResult?,
            signatureTimestamp: Date?
        ): OpenPgpSignatureResult {
            require(!(signatureStatus == RESULT_NO_SIGNATURE || signatureStatus == RESULT_KEY_MISSING || signatureStatus == RESULT_INVALID_SIGNATURE)) { "can only use this method for valid types of signatures" }
            return OpenPgpSignatureResult(
                signatureStatus, primaryUserId, keyId, userIds, confirmedUserIds,
                senderStatusResult, null, signatureTimestamp, null
            )
        }

        public fun createWithNoSignature(): OpenPgpSignatureResult {
            return OpenPgpSignatureResult(
                RESULT_NO_SIGNATURE,
                null,
                0L,
                null,
                null,
                null,
                null,
                null,
                null
            )
        }

        public fun createWithKeyMissing(keyId: Long, signatureTimestamp: Date?): OpenPgpSignatureResult {
            return OpenPgpSignatureResult(
                RESULT_KEY_MISSING,
                null,
                keyId,
                null,
                null,
                null,
                null,
                signatureTimestamp,
                null
            )
        }

        public fun createWithInvalidSignature(): OpenPgpSignatureResult {
            return OpenPgpSignatureResult(
                RESULT_INVALID_SIGNATURE,
                null,
                0L,
                null,
                null,
                null,
                null,
                null,
                null
            )
        }

        private fun <T : Enum<T>?> readEnumWithNullAndFallback(
            source: Parcel,
            enumValues: Array<T>,
            fallback: T?
        ): T? {
            val valueOrdinal = source.readInt()
            if (valueOrdinal == -1) {
                return null
            }
            return if (valueOrdinal >= enumValues.size) {
                fallback
            } else enumValues[valueOrdinal]
        }

        private fun writeEnumWithNull(dest: Parcel, enumValue: Enum<*>?) {
            if (enumValue == null) {
                dest.writeInt(-1)
                return
            }
            dest.writeInt(enumValue.ordinal)
        }
    }
}