All Classes and Interfaces
Class
Description
The AEADCipher class is the abstract base class for Authenticated Encryption
with Associated Data (AEAD) ciphers.
AESKey contains a 16/24/32 byte key for AES computations based
on the Rijndael algorithm.This class encapsulates the Application Identifier (AID) associated with an
applet.
A (transparent) specification of cryptographic parameters.
Application Protocol Data Unit (APDU) is the communication format between the
card and the off-card applications.
APDUException represents an APDU related
exception.The
APDUUtil class contains utility methods to parse CLA byte from
a command APDU.This abstract class defines an Java Card technology-based applet.
The
AppletEvent interface provides a callback interface for
the Java Card runtime environment to inform the applet about life cycle
events.A Java Card runtime environment-owned instance of
ArithmeticException is thrown when an exceptional arithmetic
condition has occurred.
A Java Card runtime environment-owned instance of
ArrayIndexOutOfBoundsException is thrown to indicate that an
array has been accessed with an illegal index.The
ArrayLogic class contains common utility functions for
manipulating arrays of primitive components - byte, short or int.A Java Card runtime environment-owned instance of
ArrayStoreException is thrown to indicate that an attempt has
been made to store the wrong type of object into an array of objects.This class should be used as the base class for implementing services.
The
BCDUtil class contains common BCD(binary coded decimal)
related utility functions.Preview.
The
BDHKeyAgreement interface can be used for KeyAgreement instances supporting
Elliptic Curve Blinded Diffie-Hellman Key Exchange protocol as defined in
EMV Contactless Specifications for Payment Systems - Book E Security and Key Management - Version 1.1 Feb 2025.The abstract
BERTag class encapsulates a BER TLV tag.The abstract
BERTLV class encapsulates a BER TLV structure.The
BigNumber class encapsulates an unsigned number whose
value is represented in internal hexadecimal format using an implementation
specific maximum number of bytes.The
Bio1toNBuilder class is a BioMatcher object factory.The
Bio1toNException class encapsulates specific exceptions which
can be thrown by the methods of the javacardx.biometry1toN package
in case of error.Builds an empty/blank biometric reference template.
The
BioException class encapsulates specific exceptions which
can be thrown by the methods of the javacardx.biometry package
in case of error.The
BioMatcher interface is the base interface for biometric
matching.The BioTemplate interface is the base interface for all biometric templates.
The
BioTemplateData interface is the base interface for all
biometric template data container.A container for data of a specific primitive type.
Unchecked exception thrown when a relative put operation reaches the
target buffer's limit.
Unchecked exception thrown when a relative get operation reaches the
source buffer's limit.
A byte buffer.
A typesafe enumeration for byte orders.
The
CardException class defines a field reason and
two accessor methods
getReason() and setReason().A convenient base class for remote objects for the Java Card platform.
The
CardRuntimeException class defines a field
reason and two accessor methods
getReason() and
setReason().The
Certificate interface is the base interface for all
certificate types.CertificateException represents a certificate-related exception.The
CertificateParser class is used to parse certificates and
create Certificate instances.A
KeyHandler is triggered by a CertificateParser and allows
to fill the fields of a PublicKey pre-allocated by the application
with the values of the public key of the certificate.ParserHandler is the base interface for all handlers that can be
triggered by the CertificateParser at the time a certificate is built or parsed.The
Checksum class is the base class for CRC (cyclic
redundancy check) checksum algorithms.The
Cipher class is the abstract base class for Cipher
algorithms.The
OneShot class is a specialization of the Cipher
class intended to support efficient one-shot ciphering and deciphering
operations that may avoid persistent memory writes entirely.A Java Card runtime environment-owned instance of
ClassCastException is thrown to indicate that the code has
attempted to cast an object to a subclass of which it is not an instance.The
ConstructedBERTag class encapsulates a constructed BER TLV
tag.The
ConstructedBERTLV class encapsulates a constructed BER TLV
structure.CryptoException represents a cryptography-related exception.Exception used to indicate a problem while calculating a date-time.
The
DerivationFunction class is the abstract class for
derivation functions.The
OneShot class is a specialization of the DerivationFunction
class intended to support efficient one-shot derivation function
operations that may avoid persistent memory writes entirely.DESKey contains an 8/16/24-byte key for single/2 key triple
DES/3 key triple DES operations.The
DHKey interface is the base interface for the DH
algorithm's private and public key implementations.The
DHPrivateKey interface is used to sign data using the DH
algorithm.The
DHPublicKey interface is used to verify signatures on
signed data using the DH algorithm.A
Dispatcher is used to build an application by aggregating
several services.The
DSAKey interface is the base interface for the DSA
algorithm's private and public key implementations.The
DSAPrivateKey interface is used to sign data using the DSA
algorithm.The
DSAPublicKey interface is used to verify signatures on
signed data using the DSA algorithm.The
ECKey interface is the base interface for the EC
algorithm's private and public key implementations.The
ECPrivateKey interface is used to generate signatures on
data using the ECDSA (Elliptic Curve Digital Signature Algorithm) and to
generate shared secrets using the ECDH (Elliptic Curve Diffie-Hellman)
algorithm.The
ECPublicKey interface is used to verify signatures on
signed data using the ECDSA algorithm and to generate shared secrets using
the ECDH algorithm.A tagging interface that all event listener interfaces must extend.
An event registry instance is used by applications to register or unregister
event listeners for a particular source of events.
A tagging interface that all event source must implement.
The class
Exception and its subclasses are a form of
Throwable that indicate conditions that a reasonable applet
might want to catch.The
ExtendedLength interface serves as a tagging interface to
indicate that the applet supports extended length APDU.ExternalException represents an external subsystem related
exception.GenericSecretKey contains sensitive data value.HMACKey contains a key for HMAC operations.A Java Card runtime environment-owned instance of
IndexOutOfBoundsException is thrown to indicate that an index
of some sort (such as to an array) is out of range.The
InitializedMessageDigest class is a subclass of the base
class MessageDigest.The
OneShot class is a specialization of the
InitializedMessageDigest class intended to support efficient one-shot
hash operations that may avoid persistent memory writes entirely.A Java Card runtime environment-owned instance of
IOException
is thrown to signal that an I/O exception of some sort has occurred.ISO7816 encapsulates constants related to ISO 7816-3 and ISO
7816-4.ISOException class encapsulates an ISO 7816-4 response status
word as its reason code.The
JCint class contains common utility functions using ints.The
JCSystem class includes a collection of methods to control
applet execution, resource management, atomic transaction management, object
deletion mechanism and inter-applet object sharing in the Java Card
environment.This interface specifies the set of parameters used to instantiate a
DerivationFunction implementing the KDF Key Derivation Function defined in
in the standard ANSI X9.63.This interface specifies the set of parameters used to instantiate a
DerivationFunction implementing KDF in Counter Mode defined in NIST
SP 800-108 (Recommendation for Key Derivation Using Pseudorandom Functions).This interface specifies the set of parameters used to instantiate a
DerivationFunction implementing KDF in Double Pipeline Iteration Mode
defined in NIST SP 800-108 (Recommendation for Key Derivation Using
Pseudorandom Functions).This interface specifies the set of parameters used to instantiate a
DerivationFunction implementing KDF in Feedback Mode defined in NIST
SP 800-108 (Recommendation for Key Derivation Using Pseudorandom Functions).This interface specifies the set of parameters used to instantiate a
DerivationFunction implementing the HKDF Key Derivation function defined in
in IETF RFC 5869.This interface specifies the set of parameters used to instantiate a
DerivationFunction implementing KDF Key Derivation Function defined in
the standard ICAO MRTD Doc 9303.This interface specifies the set of parameters used to instantiate a
DerivationFunction implementing the the KDF1 Key Derivation Function defined in
the standard IEEE 1363-2000.The
Key interface is the base interface for all keys.The
KeyAgreement class is the base class for key agreement
algorithms such as Diffie-Hellman and EC Diffie-Hellman [IEEE P1363].The
KeyBuilder class is a key object factory.KeyEncryption interface defines the methods used to enable
encrypted key data access to a key implementation.This class is a container for a key pair (a public key and a private key).
KoreanSEEDKey contains an 16-byte key for Korean Seed
Algorithm operations.This class provides access to memory subsystems that are not directly
addressable, typically that of other contactless state machine handlers such
as MifareTM.
This interface provides methods to read and write the external memory space.
The
MessageDigest class is the base class for hashing
algorithms.The
OneShot class is a specialization of the
MessageDigest class intended to support efficient one-shot hash
operations that may avoid persistent memory writes entirely.A
MonotonicCounter represents a number that can only be
increased, never decreased.The
MultiSelectable interface identifies the implementing
Applet subclass as being capable of concurrent selections.This class is used to specify any algorithm parameters that are determined by
a standard name.
A Java Card runtime environment-owned instance of
NegativeArraySizeException is thrown if an applet tries to
create an array with negative size.A Java Card runtime environment-owned instance of
NullPointerException is thrown when an applet attempts to use
null in a case where an object is required.Class
Object is the root of the Java Card platform class
hierarchy.The
OwnerBioMatcher interface should be implemented by the applet
which owns the BioMatcher.The
OwnerBioTemplate interface should be implemented by the
applet which owns the biometric template.The
OwnerBioTemplateData interface should be implemented by the
applet which owns the Biometric Template Data containers.This class represents an Owner PIN, implements Personal Identification Number
functionality as defined in the
PIN interface, and provides
the ability to update the PIN and thus owner functionality.The
OwnerPINBuilder class is factory for Owner PIN objects.The
OwnerPINx interface represents an Owner PIN,
extends Personal Identification Number functionality as defined in the
PIN interface, and provides the ability to update the PIN, update the try limit
and try counter and thus owner functionality.The
OwnerPINxWithPredecrement interface represents an Owner PIN,
extends Personal Identification Number functionality as defined in the
PIN interface, and provides the ability to update the PIN, update the try limit
and try counter and thus owner functionality.The
ParityBit class is a utility to assist with DES key parity
bit generation.This interface represents a PIN.
PINException represents a OwnerPIN class or OwnerPINx
-implementing class access-related exception.The
PrimalityTestParamSpec interface can be used for key
pair generation (e.g RSA) for configuring the primality test algorithm.The
PrimitiveBERTag class encapsulates a primitive BER TLV
tag.The
PrimitiveBERTLV class encapsulates a primitive BER TLV
structure.The
PrivateKey interface is the base interface for private
keys used in asymmetric algorithms.The
PublicKey interface is the base interface for public keys
used in asymmetric algorithms.The
RandomData abstract class is the base class for random
number generation.The
OneShot class is a specialization of the RandomData
class intended to support efficient one-shot random data generation
operations that may avoid persistent memory writes entirely.Unchecked exception thrown when a content-mutation method such as
put or compact is invoked upon a read-only buffer.The Remote interface serves to identify interfaces whose methods may be
invoked from a CAD client application.
A Java Card runtime environment-owned instance of
RemoteException is thrown to indicate that a
communication-related exception has occurred during the execution of a remote
method call.This interface defines the generic API for remote object access services,
which allow remote processes to access the services present on a Java Card
technology-enabled smart card.
An instance of
Resources provides means to read the resources
accessible to the caller code.An implementation of a service that is used to process Java Card platform RMI
requests for remotely accessible objects.
The
RSAPrivateCrtKey interface is used to sign data using the
RSA algorithm in its Chinese Remainder Theorem form.The
RSAPrivateKey class is used to sign data using the RSA
algorithm in its modulus/exponent form.The
RSAPublicKey is used to verify signatures on signed data
using the RSA algorithm.RuntimeException is the superclass of those exceptions that
can be thrown during the normal operation of the Java Card Virtual Machine.The
SecretKey class is the base interface for keys used in
symmetric algorithms (DES, for example).A Java Card runtime environment-owned instance of
SecurityException is thrown by the Java Card Virtual Machine
to indicate a security violation.This interface describes the functions of a generic security service.
The
SensitiveArrays class provides methods for creating and handling
integrity-sensitive array objects.The
SensitiveResult class provides methods for asserting results of
sensitive functions.This is the base interface for the service framework on the Java Card
platform.
ServiceException represents a service framework-related
exception.The Shareable interface serves to identify all shared objects.
The
SharedBioMatcher interface provides the means for accessing unrestricted matching biometric functionality,
e.g., the biometric matching functions.The
SharedBioTemplate interface provides the means for
accessing unrestricted biometric functionality, e.g., the biometric matching
functions.The
SharedBioTemplateData interface provides the means for accessing
unrestricted biometric template data.The
Signature class is the base class for Signature
algorithms.The
OneShot class is a specialization of the
Signature class intended to support efficient one-shot signing and
verification operations that may avoid persistent memory writes entirely.A subclass of the abstract
Signature class must implement this
SignatureMessageRecovery interface to provide message recovery
functionality.The
SM2KeyAgreementParameterSpec interface can be used for KeyAgreement
operation as defined in the GM/T 0003.3-2012 (Public Key
Cryptographic Algorithm SM2 Based on Elliptic Curves Part 3: Key
Exchange Protocol).SM4Key contains a 128-bit key for SM4 computations.Defines a character string constant.
StringException represents a StringUtil class related exception.Defines a pool of character string constants.
This class provides methods for handling UTF-8 encoded character sequences (strings).
SystemException represents a JCSystem class
related exception.Class used to handle system time, suitable for timestamps or for estimating
intervals between events.
The Throwable class is the superclass of all errors and exceptions in the
Java Card platform's subset of the Java programming language.
A time-based amount of time.
This interface specifies the set of parameters used to instantiate a
DerivationFunction implementing the Key Derivation HKDF-Expand-LabelThis interface specifies the set of parameters used to instantiate a
DerivationFunction implementing TLS pseudo random function for TLS
version 1.1 defined in IETF RFC 4346 or version 1.2 defined in IETF RFC 5246.TLVException represents a TLV-related exception.TransactionException represents an exception in the
transaction subsystem.UserException represents a User exception.The
Util class contains common utility functions.UtilException represents a util related exception.The
X509Certificate interface is the interface to represent X509
certificates as specified in RFC 5280.ExtensionHandler is a specialized CertificateParser.ParserHandler that will be
triggered by the CertificateParser each time a certificate extension
is found.FieldHandler is a specialized CertificateParser.ParserHandler that will be
triggered by the CertificateParser each time a certificate field
is found.The
XECKey interface is the base interface for all EC keys used
for named curves with predefined parameters and encoding.The
XECPrivateKey interface is the base interface for EC private
keys for named curves with predefined parameters.The
XECPublicKey interface is the base interface for EC public
keys for named curves with predefined parameters.