|
||||||||||
| PREV NEXT | FRAMES NO FRAMES | |||||||||
AESKey contains a 16/24/32 byte key for AES computations based
on the Rijndael algorithm.AID instance
encapsulating the specified AID bytes.
ALG_AES_BLOCK_128_CBC_NOPAD provides a cipher using AES with
block size 128 in CBC mode and
does not pad input data.
ALG_AES_BLOCK_128_ECB_NOPAD provides a cipher using AES with
block size 128 in ECB mode and
does not pad input data.
ALG_AES_MAC_128_NOPAD generates a 16-byte MAC
using AES with blocksize 128 in CBC mode and does not pad input data.
ALG_DES_CBC_ISO9797_M1 provides a cipher using DES
in CBC mode or triple DES in outer CBC mode, and pads
input data according to the ISO 9797 method 1 scheme.
ALG_DES_CBC_ISO9797_M2 provides a cipher using DES
in CBC mode or triple DES in outer CBC mode, and pads
input data according to the ISO 9797 method 2 (ISO 7816-4, EMV'96) scheme.
ALG_DES_CBC_NOPAD provides a cipher using DES in CBC mode
or triple DES in outer CBC mode, and
does not pad input data.
ALG_DES_CBC_PKCS5 provides a cipher using DES
in CBC mode or triple DES in outer CBC mode, and pads
input data according to the PKCS#5 scheme.
ALG_DES_ECB_ISO9797_M1 provides a cipher using DES
in ECB mode, and pads
input data according to the ISO 9797 method 1 scheme.
ALG_DES_ECB_ISO9797_M2 provides a cipher using DES
in ECB mode, and pads
input data according to the ISO 9797 method 2 (ISO 7816-4, EMV'96) scheme.
ALG_DES_ECB_NOPAD provides a cipher using DES in ECB mode,
and does not pad input data.
ALG_DES_ECB_PKCS5 provides a cipher using DES
in ECB mode, and pads
input data according to the PKCS#5 scheme.
ALG_DES_MAC4_ISO9797_1_M2_ALG3 generates a 4-byte MAC
using a 2-key DES3 key according to ISO9797-1 MAC algorithm 3 with method 2 (also
EMV'96, EMV'2000), where input data is padded using method 2 and the data is processed
as described in MAC Algorithm 3 of the ISO 9797-1 specification.
ALG_DES_MAC4_ISO9797_M1 generates a 4-byte MAC
(most significant 4 bytes of encrypted block) using DES in CBC mode
or triple DES in outer CBC mode.
ALG_DES_MAC4_ISO9797_M2 generates a 4-byte MAC
(most significant 4 bytes of encrypted block) using DES in CBC mode
or triple DES in outer CBC mode.
ALG_DES_MAC4_NOPAD generates a 4-byte MAC
(most significant 4 bytes of encrypted block) using DES in CBC mode
or triple DES in outer CBC mode.
ALG_DES_MAC4_PKCS5 generates a 4-byte MAC
(most significant 4 bytes of encrypted block) using DES in CBC mode
or triple DES in outer CBC mode.
ALG_DES_MAC8_ISO9797_1_M2_ALG3 generates an 8-byte MAC
using a 2-key DES3 key according to ISO9797-1 MAC algorithm 3 with method 2 (also
EMV'96, EMV'2000), where input data is padded using method 2 and the data is processed
as described in MAC Algorithm 3 of the ISO 9797-1 specification.
ALG_DES_MAC8_ISO9797_M1 generates an 8-byte MAC
using DES in CBC mode or triple DES in outer CBC mode.
ALG_DES_MAC8_ISO9797_M2 generates an 8-byte MAC
using DES in CBC mode or triple DES in outer CBC mode.
ALG_DES_MAC_8_NOPAD generates an 8-byte MAC
using DES in CBC mode or triple DES in outer CBC mode.
KeyPair object containing a DSA key pair.
ALG_DSA_SHA generates a
20-byte SHA digest and signs/verifies the digests using DSA.
KeyPair object containing an EC key pair for
EC operations over fields of characteristic 2 with polynomial
basis.
KeyPair object containing an EC key pair for
EC operations over large prime fields
ALG_ECDSA_SHA generates a 20-byte
SHA digest and signs/verifies the digest using ECDSA.
KeyPair object containing a RSA key pair.
KeyPair object containing a RSA key pair with private key in
its Chinese Remainder Theorem form.
ALG_RSA_ISO14888 provides a cipher using RSA, and pads
input data according to the ISO 14888 scheme.
ALG_RSA_ISO9796 should not be used.
ALG_RSA_MD5_PKCS1 generates a 16-byte MD5 digest,
pads the digest according to the PKCS#1 (v1.5) scheme,
and encrypts it using RSA.
ALG_RSA_MD5_PKCS1_PSS generates a 16-byte MD5 digest,
pads it according to the PKCS#1-PSS scheme (IEEE 1363-2000),
and encrypts it using RSA.
ALG_RSA_MD5_RFC2409 generates a 16-byte MD5 digest,
pads the digest according to the RFC2409 scheme,
and encrypts it using RSA.
ALG_RSA_NOPAD provides a cipher using RSA and
does not pad input data.
ALG_RSA_PKCS1 provides a cipher using RSA, and pads
input data according to the PKCS#1 (v1.5) scheme.
ALG_RSA_PKCS1_OAEP provides a cipher using RSA, and
pads input data according to the PKCS#1-OAEP scheme (IEEE 1363-2000).
ALG_RSA_RIPEMD160_ISO9796 generates a 20-byte RIPE MD-160 digest,
pads the digest according to the ISO 9796 scheme,
and encrypts it using RSA.
ALG_RSA_RIPEMD160_PKCS1 generates a 20-byte RIPE MD-160 digest,
pads the digest according to the PKCS#1 (v1.5) scheme,
and encrypts it using RSA.
ALG_RSA_RIPEMD160_PKCS1_PSS generates a 20-byte RIPE MD-160 digest,
pads it according to the PKCS#1-PSS scheme (IEEE 1363-2000),
and encrypts it using RSA.
ALG_RSA_SHA_ISO9796 generates
a 20-byte SHA digest, pads the digest according to the ISO 9796-2 scheme
as specified in EMV '96 and EMV 2000, and encrypts it using RSA.
ALG_RSA_SHA_PKCS1 generates a 20-byte SHA digest,
pads the digest according to the PKCS#1 (v1.5) scheme,
and encrypts it using RSA.
ALG_RSA_SHA_PKCS1_PSS generates a 20-byte SHA-1 digest,
pads it according to the PKCS#1-PSS scheme (IEEE 1363-2000),
and encrypts it using RSA.
ALG_RSA_SHA_RFC2409 generates a 20-byte SHA digest,
pads the digest according to the RFC2409 scheme,
and encrypts it using RSA.
APDUException represents an APDU related exception.install() method should create the applet object.
AppletEvent interface provides a callback interface for
the Java Card runtime environment to inform the applet about life cycle events.APDU.setOutgoingLength() method to indicate
that the length parameter is greater that 256 or
if non BLOCK CHAINED data transfer is requested and len is greater than
(IFSD-2), where IFSD is the Outgoing Block Size.
APDU.sendBytes() method to indicate
that the sum of buffer offset parameter and the byte length parameter exceeds the APDU
buffer size.
ByteContainer
with memory type JCSystem.MEMORY_TYPE_PERSISTENT
ByteContainer
with defined memory type
ByteContainer
with memory type JCSystem.MEMORY_TYPE_PERSISTENT
and fills it by byte representation of BigInteger
ByteContainer
with memory type JCSystem.MEMORY_TYPE_PERSISTENT
and fills it by defined byte array
CardException class
defines a field reason and two accessor methods
getReason() and setReason().CardRuntimeException class
defines a field reason and two accessor methods
getReason() and setReason().pin against the PIN value.
pin against the PIN value.
Checksum class is the base class for CRC (cyclic redundancy check) checksum algorithms.Cipher class is the abstract base class for Cipher algorithms.ByteContainer
CLEAR_ON_RESET cases.
Applet instance in Simulator
CryptoException represents a cryptography-related exception.CryptoException with the specified reason.
DESKey contains an 8/16/24-byte key for single/2 key triple DES/3 key triple DES
operations.DSAPublicKeyImpl/DSAPrivateKeyImpl
on BouncyCastle CryptoAPIDSAPrivateKey interface is used to sign data using the DSA algorithm.DSAPrivateKey based
on BouncyCastle CryptoAPIDSAPublicKey interface is used to verify signatures
on signed data using the DSA algorithm.DSAPublicKey based
on BouncyCastle CryptoAPIECKey interface is the base interface for the EC algorithm's private
and public key implementations.ECPublicKeyImpl/ECPrivateKeyImpl on BouncyCastle CryptoAPIECPrivateKey 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.ECPrivateKey based
on BouncyCastle CryptoAPIECPublicKey interface is used to verify signatures on signed data
using the ECDSA algorithm and to generate shared secrets using the ECDH
algorithm.ECPublicKey based
on BouncyCastle CryptoAPIthis AID instance to the AID bytes in the
specified object.
bArray are the same as those encapsulated
in this AID object.
PrivateKey specified during initialization and the public key data
provided.
KeyPair instance with new key values.
KeyPair instance
with new key values.
AID object associated with
the current applet context, or
null if the Applet.register() method
has not yet been invoked.
AID object associated with
the current applet context, or
null if the Applet.register() method
has not yet been invoked.
Applet by it's AID or null
Applet class by it's AID or null
BigInteger representation of the ByteContainer
ByteContainer
ByteContainer
BlockCipher for using with this key
APDU command
based on the CLA byte.
APDU object.
APDU object.
ECDomainParameters
Checksum object instance of the selected algorithm.
KeyAgreement object instance of the selected algorithm.
MessageDigest object instance of the selected algorithm.
RandomData instance of the selected algorithm.
Signature object instance of the selected algorithm.
Cipher object instance of the selected algorithm.
Key data in plain text.
Key data in plain text.
Key data in plain text.
Cipher object to be used to decrypt the input key data
and key parameters in the set methods.
DSAKeyGenerationParameters
ECKeyGenerationParameters
RSAKeyGenerationParameters
DSAKeyParameters
ECPrivateKeyParameters
ECPublicKeyParameters
RSAKeyParameters
KeyParameter of the key
AID object starting
at the specified offset for the specified length.
AID object associated
with the previously active applet context.
AID object associated
with the previously active applet context.
KeyPair object.
KeyPair object.
KeyPair object.
KeyPair object.
PIN is blocked.
PIN is blocked.
javacard.framework.Applet.register() method
to indicate that the input AID parameter is not a legal AID value.
beginTransaction method to indicate
a transaction is already in progress.
Checksum object with the algorithm specific
Note:
The ALG_ISO3309_CRC16 algorithm expects 2 bytes of parameter information in
bArray representing the initial checksum value.
Signature object with the appropriate Key.
Signature object with the appropriate Key and algorithm specific
parameters.
Cipher object with the appropriate Key.
Cipher object with the appropriate Key and algorithm specific
parameters.
Applet subclass, the Java Card runtime environment
will call this static method first.
Applet into Simulator without installing data
Applet into Simulator.
Applet into Simulator.
Applet into Simulator.
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.true if a valid PIN has been presented since the last
card reset or last call to reset().
true if a valid PIN value has been presented since the last
card reset or last call to reset().
JavaCardInterfaceJCSystem 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.Key interface is the base interface for all keys.KeyAgreement class is the base class for key agreement algorithms
such as Diffie-Hellman and EC Diffie-Hellman [IEEE P1363].KeyAgreement based
on BouncyCastle CryptoAPIKeyEncryption interface defines the methods used to enable encrypted
key data access to a key implementation.Key instancesKeyPair instance for the specified algorithm and keylength;
the encapsulated keys are uninitialized.
KeyPair object containing the specified
public key and private key.
KeyPair based on BouncyCastle CryptoAPIKeyPair instance for the specified algorithm and keylength;
the encapsulated keys are uninitialized.
KeyPair object containing the specified public key and
private key.
LENGTH_AES_128 = 128.
LENGTH_AES_192 = 192.
LENGTH_AES_256 = 256.
LENGTH_DES = 64.
LENGTH_DES3_2KEY = 128.
LENGTH_DES3_3KEY = 192.
LENGTH_DSA_1024 = 1024.
LENGTH_DSA_512 = 512.
LENGTH_DSA_768 = 768.
LENGTH_EC_F2M_113 = 113.
LENGTH_EC_F2M_131 = 131.
LENGTH_EC_F2M_163 = 163.
LENGTH_EC_F2M_193 = 193.
LENGTH_EC_FP_112 = 112.
LENGTH_EC_FP_128 = 128.
LENGTH_EC_FP_160 = 160.
LENGTH_EC_FP_192 = 192.
LENGTH_RSA_1024 = 1024.
LENGTH_RSA_1280 = 1280.
LENGTH_RSA_1536 = 1536.
LENGTH_RSA_1984 = 1984.
LENGTH_RSA_2048 = 2048.
LENGTH_RSA_512 = 512.
LENGTH_RSA_736 = 736.
LENGTH_RSA_768 = 768.
LENGTH_RSA_896 = 896.
Applet into Simulator
Applet into Simulator
Applet into Simulator
AID object, if any,
encapsulating the specified AID bytes in the buffer parameter
if there exists a successfully installed applet on the card whose instance AID
exactly matches that of the specified AID bytes.
AID object, if any,
encapsulating the specified AID bytes in the buffer parameter
if there exists a successfully installed applet on the card whose instance AID
exactly matches that of the specified AID bytes.
Object with the specified array length.
Object with the specified array length.
MessageDigest class is the base class for hashing algorithms.MessageDigest based
on BouncyCastle CryptoAPIinit() methods to indicate decryption mode.
init() methods to indicate encryption mode.
init() methods to indicate signature sign mode.
init() methods to indicate signature verify mode.
MultiSelectable interface identifies the implementing
Applet subclass as being capable of concurrent selections.makeTransient..() methods
to indicate that no room is available in volatile memory for the requested object.
abortTransaction and commitTransaction methods
when a transaction is not in progress.
PIN interface, and
provides the ability to update the PIN and thus owner functionality.length bytes
of the encapsulated AID bytes within this AID object.
PINException represents a OwnerPIN class access-related exception.PrivateKey interface is the base interface for private keys used in asymmetric algorithms.PublicKey interface is the base interface for public keys used in asymmetric algorithms.RandomData abstract class is the base class for random number generation.RandomData based
on BouncyCastle CryptoAPIthis applet instance with
the Java Card runtime environment and to
assign the Java Card platform name of the applet as its instance AID bytes.
this applet instance with the Java Card runtime environment and
assign the specified AID bytes as its instance AID bytes.
this applet instance with
the Java Card runtime environment and to
assign the Java Card platform name of the applet as its instance AID bytes.
this applet instance with the Java Card runtime environment and
assign the specified AID bytes as its instance AID bytes.
PIN try counter to the value of the PIN try limit.
PIN try counter to the value of the PIN try limit.
MessageDigest object to the initial state for further use.
PIN try counter to the value of the PIN try limit.
otherAID object matches
that of this AID object.
RSAPublic/RSAPrivate based on BouncyCastle CryptoAPIRSAPrivateCrtKey interface is used to sign data using the RSA algorithm
in its Chinese Remainder Theorem form.RSAPrivateCrtKey based
on BouncyCastle CryptoAPIRSAPrivateKey class is used to sign data using the RSA algorithm
in its modulus/exponent form.RSAPublicKey is used to verify signatures on signed data using the RSA algorithm.SecretKey class is the base interface for keys
used in symmetric algorithms (DES, for example).process() method to distinguish
the SELECT APDU command which selected this applet, from all other
other SELECT APDU commands which may relate to file or internal applet state selection.
len more bytes from outData byte array starting at specified offset
bOff.
ByteContainerby byte representation of BigInteger
ByteContainerby defined byte array
ByteContainerby defined byte array
TYPE_EC_F2M_PUBLIC or TYPE_EC_F2M_PRIVATE in
the case where the polynomial is a trinomial, of the form
x^n + x^e + 1 (where n is the bit length of the key).
TYPE_EC_F2M_PUBLIC or TYPE_EC_F2M_PRIVATE in
the case where the polynomial is a pentanomial, of the form
x^n + x^e1 + x^e2 + x^e3 + 1 (where n is the bit length of the key).
TYPE_EC_FP_PRIVATE or TYPE_EC_FP_PUBLIC.
Key data.
Key data.
Key data.
Cipher object to be used to decrypt the input key data
and key parameters in the set methods.
Signature class is the base class for Signature algorithms.JCSystemAPDU object occurs when an APDUException
with reason code APDUException.IO_ERROR has been
thrown
APDU object occurs when an APDUException
with reason code APDUException.NO_T0_GETRESPONSE has been
thrown.
APDU object occurs when an APDUException
with reason code APDUException.NO_T0_REISSUE has been
thrown.
APDU object occurs when an APDUException
with reason code APDUException.T1_IFD_ABORT has been
thrown.
APDU object when all the
incoming data been received.
APDU object when all outbound data
has been transferred.
APDU object when only the command
header is valid.
APDU object when data transfer
mode is outbound but length is not yet known.
APDU object when data transfer
mode is outbound and outbound length is known.
APDU object when incoming data
has partially been received.
APDU object when some outbound
data has been transferred but not all.
Cipher with symmetric keys based
on BouncyCastle CryptoAPISymmetricKeyImpl
Signature with symmetric keys based
on BouncyCastle CryptoAPISystemException represents a JCSystem class related exception.APDUException with the specified reason.
CardException class with the
specified reason.
CardRuntimeException class with the
specified reason.
PINException with the specified reason.
SystemException with the specified reason.
TransactionException with the specified reason.
UserException with the specified reason.
CryptoException with the specified reason.
TransactionException represents an exception in the transaction subsystem.Key object which implements interface type AESKey with persistent key data.
Key object which implements interface type AESKey
with CLEAR_ON_DESELECT transient key data.
Key object which implements interface type AESKey
with CLEAR_ON_RESET transient key data.
Key object which implements interface type DESKey with persistent key data.
Key object which implements interface type DESKey
with CLEAR_ON_DESELECT transient key data.
Key object which implements interface type DESKey
with CLEAR_ON_RESET transient key data.
Key object which implements the interface type DSAPrivateKey
for the DSA algorithm.
Key object which implements the interface type DSAPublicKey
for the DSA algorithm.
ECPrivateKey
for EC operations over fields of characteristic 2 with polynomial
basis.
ECPublicKey
for EC operations over fields of characteristic 2 with polynomial
basis.
ECPrivateKey
for EC operations over large prime fields.
ECPublicKey
for EC operations over large prime fields.
Key object which implements interface type RSAPrivateCrtKey which
uses Chinese Remainder Theorem.
Key object which implements interface type RSAPrivateKey which
uses modulus/exponent form.
Key object which implements interface type RSAPublicKey.
PIN try
counter to the value of the PIN try limit.
UserException represents a User exception.UserException with reason = 0.
UserException with the specified reason.
Util class contains common utility functions.
|
||||||||||
| PREV NEXT | FRAMES NO FRAMES | |||||||||