tink

type Aead interface {
	// Encrypt encrypts {@code plaintext} with {@code additionalData} as additional
	// authenticated data. The resulting ciphertext allows for checking
	// authenticity and integrity of additional data ({@code additionalData}),
	// but does not guarantee its secrecy.
	Encrypt(plaintext []byte, additionalData []byte) ([]byte, error)

	// Decrypt decrypts {@code ciphertext} with {@code additionalData} as additional
	// authenticated data. The decryption verifies the authenticity and integrity
	// of the additional data, but there are no guarantees wrt. secrecy of that data.
	Decrypt(ciphertext []byte, additionalData []byte) ([]byte, error)
}

type Entry struct {
	// contains filtered or unexported fields
}

type KeyManager interface {
	// GetPrimitiveFromSerializedKey constructs a primitive instance for the key given in
	// serializedKey, which must be a serialized key protocol buffer handled by this manager.
	GetPrimitiveFromSerializedKey(serializedKey []byte) (interface{}, error)

	// GetPrimitiveFromKey constructs a primitive instance for the key given in {@code key}.
	GetPrimitiveFromKey(key proto.Message) (interface{}, error)

	// NewKeyFromSerializedKeyFormat Generates a new key according to specification in {@code serializedKeyFormat},
	// which must be a serialized key format protocol buffer handled by this manager.
	NewKeyFromSerializedKeyFormat(serializedKeyFormat []byte) (proto.Message, error)

	// NewKeyFromKeyFormat generates a new key according to specification in {@code keyFormat}.
	NewKeyFromKeyFormat(keyFormat proto.Message) (proto.Message, error)

	// DoesSupport returns true iff this KeyManager supports key type identified by {@code typeURL}.
	DoesSupport(typeURL string) bool

	// GetKeyType returns the type URL that identifes the key type of keys managed by this KeyManager.
	GetKeyType() string

	// NewKeyData generates a new {@code KeyData} according to specification in {@code serializedkeyFormat}.
	// This should be used solely by the key management API.
	NewKeyData(serializedKeyFormat []byte) (*tinkpb.KeyData, error)
}

type KeysetHandle struct {
	// contains filtered or unexported fields
}

type KeysetManager struct {
	// contains filtered or unexported fields
}

type Mac interface {

	// ComputeMac Computes message authentication code (MAC) for {@code data}.
	ComputeMac(data []byte) ([]byte, error)

	// VerifyMac verifies whether {@code mac} is a correct authentication code (MAC) for {@code data}.
	VerifyMac(mac []byte, data []byte) (bool, error)
}

type PrimitiveSet struct {
	// contains filtered or unexported fields
}

type PrivateKeyManager interface {
	KeyManager

	// GetPublicKeyData extracts the public key data from the private key.
	GetPublicKeyData(serializedKey []byte) (*tinkpb.KeyData, error)
}

type PublicKeySign interface {
	/**
	 * Computes the signature for {@code data}.
	 *
	 * @return the signature of {$code data}.
	 */
	Sign(data []byte) ([]byte, error)
}

type PublicKeyVerify interface {
	/**
	 * Verifies whether {@code signature} is a valid signature for {@code data}.
	 *
	 * @return an error if {@code signature} is not a valid signature for
	 * {@code data}; nil otherwise.
	 */
	Verify(signature []byte, data []byte) error
}