All Classes and Interfaces
Class
Description
Base interface for extra methods required for handling associated data in AEAD ciphers.
This class provides some default behavior and common implementation for a
X500NameStyle.
The AccessDescription object.
Interface for factories producing encryptor/decryptor objects supporting AEAD modes.
ParameterSpec for AEAD modes which allows associated data to be added via an algorithm parameter spec.In normal
circumstances you would only want to use this if you had to work with the pre-JDK1.7 Cipher class as associated
data is ignored for the purposes of returning a Cipher's parameters.
Source class for non-FIPS approved-mode implementations of AES based algorithms.
Factory for non-FIPS AES AEAD encryption/decryption operators.
Parameters for AES non-FIPS AEAD and MAC modes..
Specific AES key generator for non-FIPS algorithms.
Factory for non-FIPS AES key wrap/unwrap operators.
Factory for basic non-FIPS AES encryption/decryption operators.
Parameters for general AES non-FIPS block cipher modes.
Parameters for general AES non-FIPS key wrapping.
Carrier class for an agreement secret key, as well as details about the MAC key if confirmation is provided.
Basic interface for key agreement implementations.
Interface for factories producing Agreement objects supporting key agreement.
Base interface for an algorithm descriptor.
General utility class for helping with AlgorithmParameters.
X.509 Section 9.8.3.
X.509 Section 9.8.4.
Wrapper for a private key that carries annotations that can be used
for tracking or debugging.
ANSSI Elliptic curve table.
Object Identifiers belong to the French Agency, ANSSI.
Source class for implementations of ARC4 based algorithms.
ARC4/RC4 key generator.
Factory for basic ARC4/RC4 encryption/decryption operators.
Parameters for ARC4/RC4 cipher modes.
Source class for implementations of ARIA based algorithms.
Factory for ARIA AEAD encryption/decryption operators.
Parameters for ARIA AEAD and MAC modes..
ARIA key generator.
Factory for ARIA key wrap/unwrap operators.
Factory for producing ARIA MAC calculators.
Factory for basic ARIA encryption/decryption operators.
Parameters for general ARIA block cipher modes.
ARIA WRAP operator parameters for KW and KWP.
General array utilities.
Iterator backed by a specific array.
An ASN1 class that encodes to nothing, used in the OER library to deal with the Optional type.
Base class for an ASN.1 ApplicationSpecific object
Interface to parse ASN.1 ApplicationSpecific objects.
Base class for BIT STRING objects
Public facade of ASN.1 Boolean data.
Marker interface for CHOICE objects - if you implement this in a role your
own object any attempt to tag the object implicitly will convert the tag to
an explicit one as the encoding rules require.
Utility class for dumping ASN.1 objects as (hopefully) human friendly strings.
Basic interface to produce serialisers for ASN.1 encodings.
Mutable class for building ASN.1 constructed objects such as SETs or SEQUENCEs.
Supported encoding formats.
Class representing the ASN.1 ENUMERATED type.
Exception thrown in cases of corrupted or unexpected data in a stream.
Class representing the DER-type External
Base class representing the ASN.1 GeneralizedTime type.
Basic class for streaming generators.
A general purpose ASN.1 decoder - note: this class differs from the
others in that it returns null after it has read the last object in
the stream.
Class representing the ASN.1 INTEGER type.
A NULL object - use DERNull.INSTANCE for populating structures.
Base class for defining an ASN.1 object.
Class representing the ASN.1 OBJECT IDENTIFIER type.
Abstract base for the ASN.1 OCTET STRING data type
A basic parser for an OCTET STRING object
Stream that produces output based on the default encoding for the passed in objects.
Exception thrown when correctly encoded, but unexpected data is found in a stream while building an object.
Base class for ASN.1 primitive objects.
ASN.1
SEQUENCE and SEQUENCE OF constructs.A basic parser for a SEQUENCE object
ASN.1
SET and SET OF constructs.A basic parser for a SET object
A parser for ASN.1 streams which also returns, where possible, parsers for the objects it encounters.
General interface implemented by ASN.1 STRING objects for extracting the content String.
ASN.1 TaggedObject - in ASN.1 notation this is any object preceded by
a [n] where n is some number - these are assumed to follow the construction
rules (as with sequences).
Interface for the parsing of a generic tagged ASN.1 object.
- * UTC time object.
Base class for Diffie-Hellman keys.
Class for Diffie-Hellman private keys.
Class for Diffie-Hellman public keys.
Base class for Digital Signature Algorithm (DSA) keys.
Class for Digital Signature Algorithm (DSA) private keys.
Class for Digital Signature Algorithm (DSA) public keys.
Base class for DSTU-4145 keys.
Class for DSTU-4145 private keys.
Class for DSTU-4145 public keys.
Class for keys for GOST R 34.10-2001 (ECGOST) private keys.
Class for keys for GOST R 34.10-2001 (ECGOST) public keys.
Base class for Elliptic Curve (EC) keys.
Class for Elliptic Curve (EC) private keys.
Class for Elliptic Curve (EC) public keys.
Base class for Edwards Curve Diffie-Hellman (XDH) keys.
Edwards Curve Diffie-Hellman (EdDSA) private keys.
Edwards Curve Diffie-Hellman (XDH) public keys.
Base class for keys for GOST R 34.10-1994 and GOST R 34.10-2001.
Class for keys for GOST R 34.10-1994 private keys.
Class for keys for GOST R 34.10-1994 public keys.
Base interface for Public/Private keys.
Carrier class for a public key and its associated private key.
AsymmetricKeyPairGenerator<T extends Parameters,P extends AsymmetricPublicKey,S extends AsymmetricPrivateKey>
Interface describing a key generator for public/private key pairs.
Leighton-Micali Hash-Based Signatures (LMS) keys.
Leighton-Micali Hash-Based Signatures (LMS) private keys.
Leighton-Micali Hash-Based Signatures (LMS) public keys.
Interface describing a factory that creates encryptors and decryptors based on public key cryptography.
Marker interface for a private key,
Marker interface for a public key,
Base class for RSA keys.
Specific RSA key usages.
Class for RSA private keys.
Class for RSA public keys.
Base class for Edwards Curve Diffie-Hellman (XDH) keys.
Edwards Curve Diffie-Hellman (XDH) private keys.
Edwards Curve Diffie-Hellman (XDH) public keys.
Holding class for the AttributeTypeAndValue structures that make up an RDN.
Interface that parameters sets associated with MACs should conform to.
Interface describing parameters used in an authentication mode, such as for a MAC, AEAD cipher, or
a HMAC.
The AuthorityInformationAccess object.
The AuthorityKeyIdentifier object.
Utility class for converting Base32 data to bytes and back again.
A streaming Base32 encoder.
Utility class for converting Base64 data to bytes and back again.
A streaming Base64 encoder.
An EntropySourceProvider where entropy generation is based on a SecureRandom output using SecureRandom.generateSeed() in
the case of a JDK SecureRandom or SecureRandom.nextBytes() in the case of a FipsSecureRandom, or a GeneralSecureRandom.
OCSP RFC 2560, RFC 6960
LoadStoreParameter to allow configuring of the PBKDF used to generate encryption keys for
use in the keystore.
Object Identifiers belonging to iso.org.dod.internet.private.enterprise.legion-of-the-bouncy-castle (1.3.6.1.4.1.22554)
Variation of BCStyle that insists on strict ordering for equality
and hashCode comparisons
An indefinite-length encoding version of an ASN.1 ApplicationSpecific object.
A parser for indefinite-length ASN.1 ApplicationSpecific objects.
Base class for generators for indefinite-length structures.
ASN.1 OctetStrings, with indefinite length rules, and constructed form support.
A generator for indefinite-length OCTET STRINGs
A parser for indefinite-length OCTET STRINGs.
Deprecated.
Will be removed from public API.
Indefinite length SEQUENCE of objects.
A stream generator for DER SEQUENCEs
Parser for indefinite-length SEQUENCEs.
Indefinite length
SET and SET OF constructs.Parser for indefinite-length SETs.
BER TaggedObject - in ASN.1 notation this is any object preceded by
a [n] where n is some number - these are assumed to follow the construction
rules (as with sequences).
Parser for indefinite-length tagged objects.
BigInteger utilities.
The BiometricData object.
Source class for implementations of Blowfish based algorithms.
Factory for Blowfish AEAD encryption/decryption operators.
Parameters for Blowfish AEAD and MAC modes..
Blowfish key generator.
Factory for producing Blowfish MAC calculators.
Factory for basic Blowfish encryption/decryption operators.
Parameters for general Blowfish block cipher modes.
The BC FIPS provider.
A buffering class to allow translation from one format to another to
be done in discrete chunks.
A buffering class to allow translation from one format to another to
be done in discrete chunks.
An output stream that buffers data to be feed into an encapsulated output stream.
Builder and holder class for preparing SP 800-56A/56B compliant MacData.
Builder to create OtherInfo
Standard type strings for the headers of KAS/KTS MAC calculations.
Utility methods and constants for bytes.
Source class for implementations of Camellia based algorithms.
Factory for Camellia AEAD encryption/decryption operators.
Parameters for Camellia AEAD and MAC modes..
Camellia key generator.
Factory for Camellia key wrap/unwrap operators.
Factory for producing Camellia MAC calculators.
Factory for basic Camellia encryption/decryption operators.
Parameters for general Camellia block cipher modes.
Camellia WRAP operator parameters for KW and KWP.
Source class for implementations of CAST5 based algorithms.
Factory for CAST5 AEAD encryption/decryption operators.
Parameters for CAST5 AEAD and MAC modes..
CAST5 key generator.
Factory for producing CAST5 MAC calculators.
Factory for basic CAST5 encryption/decryption operators.
Parameters for general CAST5 block cipher modes.
an X509Certificate structure.
PKIX RFC-2459
The X.509 v2 CRL syntax is as follows.
This class helps to support crossCerfificatePairs in a LDAP directory
according RFC 2587
PKCS10 Certification request object.
PKCS10 CertificationRequestInfo object.
CertPolicyId, used in the CertificatePolicies and PolicyMappings
X509V3 Extensions.
Source class for implementations of ChaCha20 based algorithms.
Factory for ChaCha20-Poly1305 encryption/decryption operators.
Parameters for ChaCha20-Poly1305 cipher.
ChaCha20 key generator.
Factory for basic ChaCha20 encryption/decryption operators.
Parameters for ChaCha20 cipher.
Interface for a converter that produces a byte encoding for a char array.
A CipherInputStream is composed of an InputStream and a cipher so that read() methods return data
that are read in from the underlying InputStream but have been additionally processed by the
Cipher.
Returned stream for writing data for encryption/decryption.
A CipherOutputStream is composed of an OutputStream and a cipher so that write() methods process
the written data with the cipher, and the output of the cipher is in turn written to the
underlying OutputStream.
A simple collection backed store.
A composite private key class.
A composite key class.
Carrier class for a key pair which validates the consistency of the keys at construction time.
CRL Bag for PKCS#12
The CRLNumber object.
The CRLReason enumeration.
GOST Algorithms OBJECT IDENTIFIERS :
{ iso(1) member-body(2) ru(643) rans(2) cryptopro(2)}
Permissions that need to be configured if a SecurityManager is used.
Basic registrar class for providing defaults for cryptography services in this module.
Available properties that can be set.
Exception thrown if an attempt is made to decode invalid data, or some other failure occurs.
JcaJceHelper that obtains all algorithms using the default JCA/JCE mechanism (i.e.A DER encoding version of an application specific object.
A BIT STRING with DER encoding - the first byte contains the count of padding bits included in the byte array's last byte.
DER BMPString object encodes BMP (Basic Multilingual Plane) subset
(aka UCS-2) of UNICODE (ISO 10646) characters in codepoints 0 to 65535.
Class representing the DER-type External
Parser DER EXTERNAL tagged objects.
DER Generalized time object.
ASN.1 GENERAL-STRING data type.
Basic class for streaming DER encoding generators.
DER IA5String object - this is a ISO 646 (ASCII) string encoding code points 0 to 127.
Builder and holder class for preparing SP 800-56A/56B compliant MacData.
Builder to create OtherInfo
Standard type strings for the headers of KAS/KTS MAC calculations.
An ASN.1 DER NULL object.
DER NumericString object - this is an ascii string of characters {0,1,2,3,4,5,6,7,8,9, }.
Carrier class for a DER encoding OCTET STRING
Parser for DER encoded OCTET STRINGS
Builder and holder class for preparing SP 800-56A compliant OtherInfo.
Builder to create OtherInfo
Deprecated.
Will be removed from public API.
DER PrintableString object.
Definite length SEQUENCE, encoding tells explicit number of bytes
that the content of this sequence occupies.
A stream generator for DER SEQUENCEs
Deprecated.
Use DLSequenceParser instead
A DER encoded SET object
Deprecated.
Use DLSetParser instead
DER T61String (also the teletex string), try not to use this if you don't need to.
DER TaggedObject - in ASN.1 notation this is any object preceded by
a [n] where n is some number - these are assumed to follow the construction
rules (as with sequences).
DER UniversalString object - encodes UNICODE (ISO 10646) characters using 32-bit format.
DER UTC time object.
DER UTF8String object.
DER VisibleString object encoding ISO 646 (ASCII) character code points 32 to 126.
Source class for implementations of DES based algorithms.
Factory for DES AEAD encryption/decryption operators.
Parameters for DES AEAD and MAC modes..
DES key generator.
Factory for producing DES MAC calculators.
Factory for basic DES encryption/decryption operators.
Parameters for general DES block cipher modes.
Container class for Diffie-Hellman domain parameters.
Base interface for an DH domain parameters ID.
General index for DH Curve parameters.
Extension class for DHParameterSpec that wraps a DHDomainParameters object and provides the q domain parameter.
A DHPrivateKeySpec that also carries a set of DH domain parameters.
A DHPublicKeySpec that also carries a set of DH domain parameters.
X9.42 definition of a DHPublicKey
Parameter spec to provide Diffie-Hellman Unified model keys and user keying material.
Validation parameters for confirming Diffie-Hellman parameter generation.
Marker interface for a digest algorithm
The DigestInfo object.
Interface describing an operator factory for creating digest calculators.
The DirectoryString CHOICE object.
DisplayText class, used in
CertificatePolicies X509 V3 extensions (in policy qualifiers).Instances of this can be added to the CryptoServicesRegister reference queue
to ensure the dispose method is called before GC.
The DistributionPoint object.
The DistributionPointName object.
A DER encoding version of an application specific object.
A Definite length BIT STRING
Class representing the Definite-Length-type External
The DLSequence encodes a SEQUENCE using definite length form.
Parser class for DL SEQUENCEs.
The DLSet encodes ASN.1 SET value without element ordering,
and always using definite length form.
Parser class for DL SETs.
Definite Length TaggedObject - in ASN.1 notation this is any object preceded by
a [n] where n is some number - these are assumed to follow the construction
rules (as with sequences).
X9.44 Diffie-Hellman domain parameters.
Source class for non-FIPS implementations of DSA based algorithms.
DSA domain generation parameters for non-FIPS usages.
Generator for DSA domain parameters for non-FIPS usages.
DSA key pair generation parameters for non-FIPS usages.
DSA key pair generator class for non-FIPS usages.
Operator factory for creating non-FIPS DSA based signing and verification operators.
Parameters for non-FIPS DSA signatures.
Container class for DSA domain parameters.
Parameter spec for guiding the generation of DSA Domain Parameters.
Extension class for DSAParameterSpec that wraps a DSADomainParameters object and provides the validation
parameters if available.
Validation parameters for confirming DSA parameter generation.
Source class for implementations of DSTU4145 based algorithms.
DSTU4145 key pair generation parameters.
DSTU4145 key pair generator class.
Operator factory for creating little-endian format DSTU4145 based signing and verification operators.
Operator factory for creating DSTU4145 based signing and verification operators.
Parameters for DSTU4145 signatures.
Main interface for a DSTU-4145 key.
Container class for DSTU4145 parameters.
ParameterSpec for a DSTU4145 key.
DSTU4145 encodes points somewhat differently than X9.62
It compresses the point to the size of the field element
Interface that a DSTU-4145 private key needs to conform to.
This class specifies a DSTU4145 private key with its associated parameters.
Interface that a DSTU-4145 public key needs to conform to.
This class specifies a DSTU4145 public key with its associated parameters.
Command line ASN.1 Dump utility.
Executable class that displays information about the module
Source class for non-FIPS implementations of Elliptic Curve based algorithms.
Operator factory for creating non-FIPS EC DSA based signing and verification operators.
EC DSA signature parameters for non-FIPS algorithms.
EC key pair generation parameters for non-FIPS usages.
EC key pair generator class for non-FIPS usages.
base class for an elliptic curve
Elliptic curves over F2m.
Elliptic curve over Fp
Container class for Elliptic Curve domain parameters.
Base interface for an EC domain parameters ID.
General index for Elliptic Curve parameters.
Extension class for ECParameterSpec that wraps a ECDomainParameters object or an ECParameterSpec
Class representing the Elements of the finite field
F2m in polynomial basis (PB)
representation.Source class for implementations of ECGOST3410 based algorithms.
ECGOST3410 key pair generation parameters.
ECGOST3410 key pair generator class.
Operator factory for creating ECGOST3410 based signing and verification operators.
Parameters for ECGOST3410 signatures.
table of the available named parameters for GOST 3410-2001 / 2012.
Interface that a ECGOST-3410 private key needs to conform to.
This class specifies a ECGOST3410-94 private key with its associated parameters.
Interface that a ECGOST-3410 public key needs to conform to.
This class specifies a ECGOST3410-94 public key with its associated parameters.
Extension class that identifies this domain parameter set as being the ImplicitlyCa domain
parameters for this JVM.
Extension of ECParameterSpec which marks a parameter set as being the ImplicitlyCA parameters for this JVM.
Utility class for EC Keys.
Interface for classes encapsulating a point multiplication algorithm
for
ECPoints.A general class that reads all X9.62 style EC curve tables.
base class for points on elliptic curves.
Elliptic curve points over F2m
Elliptic curve points over Fp
the elliptic curve private key object from SEC 1
Base interface for an EdDSA signing/verification key.
ParameterSpec for EdDSA signature algorithms.
ParameterSpec for EdDSA signature to allow for context and preHash.
Source class for implementations of Edwards Elliptic Curve based algorithms.
Edwards Curve DSA key pair generator.
Operator factory for creating Edwards Curve DSA based signing and verification operators.
Edwards Curve key pair generation parameters.
Edwards Curve parameters with context vector
Factory for Agreement operators based on Edwards Curve Diffie-Hellman.
Edwards Curve Diffie-Hellman key pair generator.
Edwards Elliptic Curve Object Identifiers (RFC 8410)
Source class for implementations of ElGamal based algorithms.
ElGamal key pair generation parameters.
ElGamal key pair generator class.
Factory for creating ElGamal key wrap/unwrap operators.
Parameters for use with OAEP formatted key wrapping/unwrapping and encryption/decryption.
Factory for creating ElGamal encryption/decryption operators.
Base class for ElGamal encryption/decryption and key wrap/unwrap parameters.
Parameters for use with PKCS#1 v1.5 formatted key wrapping/unwrapping and encryption/decryption.
Parameters for use with unformatted encryption/decryption.
Marker interface for parameters that can also be used for key wrapping.
Interface describing an encapsulated secret extractor.
Interface describing an encapsulated secret generator, such as for RSA KTS.
Interface implemented by objects that can be converted into byte arrays.
Encode and decode byte arrays (typically from binary to 7-bit ASCII
encodings).
Exception thrown if an attempt is made to encode invalid data, or some other failure occurs.
The EncryptedData object.
EncryptedObjectStoreData ::= SEQUENCE {
encryptionAlgorithm AlgorithmIdentifier
encryptedContent OCTET STRING
}
EncryptedPrivateKeyObjectData ::= SEQUENCE {
encryptedPrivateKeyInfo EncryptedPrivateKeyInfo,
certificates SEQUENCE OF Certificate
}
EncryptedSecretKeyData ::= SEQUENCE {
keyEncryptionAlgorithm AlgorithmIdentifier,
encryptedKeyData OCTET STRING
}
Base interface describing an entropy source for a DRBG.
Base interface describing a provider of entropy sources.
Utility methods for making use of EntropySources.
The extendedKeyUsage object.
an object for the elements in the X.509 V3 extension block.
Extensions ::= SEQUENCE SIZE (1..MAX) OF Extension
Extension ::= SEQUENCE {
extnId EXTENSION.&id ({ExtensionSet}),
critical BOOLEAN DEFAULT FALSE,
extnValue OCTET STRING }
Generator for X.509 extensions
Basic 20 byte finger print class.
A runtime exception that may be thrown by a finished operation on an
UpdateOutputStream if the underlying stream throws an IOException.
Base class for the approved mode AEADOperatorFactory implementations.
Source class for approved implementations of AES based algorithms
Factory for AEAD encryption/decryption operations.
Parameters for AES AEAD and MAC modes..
AES key generator.
Factory for producing FIPS AES key wrap/unwrap operators.
Factory for producing FIPS AES MAC calculators.
Factory for basic AES encryption/decryption operators.
General AES operator parameters.
General AES operator parameters with IV
Parameters for AES key wrap operators.
Base class for the FIPS approved mode Agreement implementations.
Base class for the approved mode AgreementFactory implementations.
Base parameters class for Diffie-Hellman and MQV based key agreement algorithms.
Base class for FIPS approved algorithm identifier implementations.
FipsAsymmetricKeyPairGenerator<T extends Parameters,P extends AsymmetricPublicKey,S extends AsymmetricPrivateKey>
Base class for the FIPS approved mode AsymmetricKeyPairGenerator implementations.
Error thrown if a key pair consistency test fails.
Source class for FIPS approved mode Diffie-Hellman implementations.
Parameters for Diffie-Hellman based key agreement.
Factory for Agreement operators based on Diffie-Hellman
Factory for Unified Agreement operators based on Diffie-Hellman
Parameters for Diffie-Hellman based key agreement using DHU.
Initial builder for DHU parameters.
Parameters for generating Diffie-Hellman domain parameters.
An enumeration of DHDomainParametersID for some pre-defined DH parameter sets.
Generator class for Diffie-Hellman domain parameters.
Parameters for Diffie-Hellman key pair generation.
Key pair generator for Diffie-Hellman key pairs.
Factory for Agreement operators based on MQV
Parameters for Diffie-Hellman based key agreement using MQV.
Initial builder for MQV parameters.
Marker class for a FIPS approved digest algorithm
Base class for classes that produce digest calculators implementing the various FIPS secure hash algorithms.
Source class for FIPS approved implementations of Deterministic Random Bit Generators (DRBGs) from SP 800-90A.
Builder for SecureRandom objects based on the FIPS DRBGs.
Source class for FIPS approved implementations of DSA based algorithms.
Parameters for DSA domain parameter generation.
Domain parameter generator for DSA.
Domain parameter validator for DSA.
Parameters for DSA key pair generation.
DSA key pair generator.
Operator factory for creating DSA based signing and verification operators.
Parameters for DSA signatures.
Source class for FIPS approved implementations of Elliptic Curve algorithms.
Parameters for EC key agreement.
Factory for Agreement operators based on EC Diffie-Hellman and Cofactor Diffie-Hellman.
Factory for Agreement operators based on EC MQV
Parameters for EC DHU key agreement.
Initial builder for DHU parameters.
An enumeration of ECDomainParametersID for the NIST defined EC domain parameters.
Operator factory for creating EC DSA based signing and verification operators.
Parameters for EC DSA signatures.
Parameters for EC key pair generation.
EC key pair generator class.
Factory for Agreement operators based on EC MQV
Parameters for EC MQV key agreement.
Initial builder for MQV parameters.
Source class for implementations of Edwards Elliptic Curve based algorithms.
Edwards Curve DSA key pair generator.
Operator factory for creating Edwards Curve DSA based signing and verification operators.
Edwards Curve key pair generation parameters.
Edwards Curve parameters with context vector
Base class for the approved mode EncapsulatedSecretExtractor implementations.
Base class for the approved mode EncapsulatingSecretGenerator implementations.
The FipsBlockCipherProvider class is used to provide FIPS implementations to the general package so that the base FIPS engine can be
used in other ways than FIPS allows for.
Entropy constants for SP 800-90B.
Base class for the approved mode InputAEADDecryptor implementations.
Base class for the approved mode InputDecryptor implementations.
Source class for FIPS approved Key Derivation Function (KDF) implementations.
Parameters for the X9.63 and CONCATENATION key derivation function.
Parameters builder for the X9.63, CONCATENATION, and NoCounter key derivation function.
An enumeration of the FIPS approved psuedo-random-function (PRF) for KDFs used with key agreement.
Factory for operators that derive key material and are associated with key agreement.
An enumeration of the counter locations for Feedback Mode and Double Pipeline Iteration Mode.
Factory for Counter Mode KDFs.
Parameters for the Counter Mode key derivation function.
Parameters for the Counter Mode parameters builder.
Factory for Double Pipeline Iteration Mode KDF.
Parameters for the Double Pipeline Mode key derivation function.
Parameters for the Double Pipeline Mode parameters builder.
Factory for Feedback Mode KDFs.
Parameters for the Feedback Mode key derivation function.
Parameters for the Feedback Mode parameters builder.
Parameters for the HKDF key derivation function.
Factory for operators that derive key material using the IKEv2 KDF.
Parameters for the IKVEv2 key derivation function.
Parameters builder for the IKEv2 key derivation function.
An enumeration of the FIPS approved psuedo-random-function (PRF) for KDFs used with IKEv2.
An enumeration of the FIPS approved psuedo-random-function (PRF) for KDFs used with SP 800-108.
Factory for operators that derive key material using the SNMP KDF.
Parameters for the SNMP key derivation function.
Parameters builder for the SNMP key derivation function.
Factory for operators that derive key material using the SRTP KDF.
Parameters for the SRTP key derivation function.
Parameters for the SRTP key derivation function.
An enumeration of the FIPS approved psuedo-random-function (PRF) for KDFs used with SRTP.
Factory for operators that derive key material using the SSH KDF.
Parameters for the SSH key derivation function.
Parameters builder for the SSH key derivation function.
An enumeration of the FIPS approved psuedo-random-function (PRF) for KDFs used with SSH key exchange.
Factory for operators that derive key material using the TLS family of KDFs.
Parameters for the TLS key derivation functions.
Parameter builder for TLS 1.0/1.1
Parameter builder for TLS 1.2
An enumeration of the FIPS approved psuedo-random-function (PRF) for KDFs used with TLS.
The standard string values for TLS key calculation stages.
Parameters for the Two Step key derivation function.
Base class for the approved mode KDFOperatorFactory implementations.
Base class for the approved mode KeyedXOFOperatorFactory implementations.
Base class for the approved mode KeyUnwrapper implementations.
Base class for the approved mode KeyUnwrapper implementations which need a SecureRandom.
Base class for the approved mode KeyWrapOperatorFactory implementations.
Base class for the approved mode KeyWrapper implementations.
Base class for the approved mode KeyWrapper implementations which need a SecureRandom.
Base class for the approved mode KTSOperatorFactory implementations.
Parameters for LMS/HSS key pair generation.
Operator factory for creating LMS based signing and verification operators.
Base class for the approved mode MACOperatorFactory implementations.
Nonce generator for use with AEAD ciphers such as GCM.
Base error class for FIPS errors.
Base class for the approved mode OutputAEADDecryptor implementations.
Base class for the approved mode OutputAEADEncryptor implementations.
Base class for the approved mode OutputDecryptor implementations.
Base class for the approved mode OutputDigestCalculator implementations.
Base class for the approved mode OutputEncryptor implementations.
Base class for the approved mode OutputMACCalculator implementations.
Base class for a FIPS signature generator..
Base class for a FIPS signature generator that makes use of a SecureRandom as part of the signing process.
Base class for a FIPS signature verifier.
Base class for a FIPS signature verifier.
Base class for a FIPS extendable output function calculator.
Base class for parameter types used in FIPS implementations.
Base class for the approved mode PasswordBasedDeriverFactory implementations.
Source class for FIPS approved implementations of Password-Based Key Derivation algorithms.
Factory for password based key derivation functions that are based on PBKDF2 (PKCS#5 scheme 2).
PBKD parameters.
Initial builder for PBKDF2 parameters.
Local register that provides access to engines for FIPS algorithms for use with general/non-FIPS-approved modes of use.
Source class for FIPS approved implementations of RSA algorithms.
Parameters for RSA key pair generation.
RSA key pair generator class.
Factory for creating RSA key wrap/unwrap operators.
Factory for producing key transport operators based on RSA.
Base class for parameters used with RSA based key transport algorithms.
Parameters for RSA based key transport using OAEP.
Parameters for use with OAEP formatted key wrapping/unwrapping and encryption/decryption.
Parameters for use with PKCS#1 v1.5 format key wrapping/unwrapping.
Parameters for PKCS#1 v1.5 digest signatures.
Parameters for RSA PSS digest signatures.
Operator factory for creating RSA based signing and verification operators.
Base class for RSA digest based signature algorithm parameters.
Parameters for RSA based key transport using SVE.
Base class for RSA key wrapping/unwrapping parameters.
Parameters for RSA X9.31 digest signatures.
Base class for DRBG/RNG SecureRandom implementations that use FIPS approved algorithms.
Error thrown if a self test fails.
Source class for implementations of FIPS approved secure hash algorithms.
Parameters for HMAC modes.
Customizable SHAKE (cSHAKE) parameters.
Factory for producing extendable output function (XOF) MAC calculators.
HMAC key generator
Customizable KMAC parameters.
Factory for producing HMAC calculators.
Factory for producing digest calculators.
Customizable ParallelHash parameters.
Generic digest parameters.
Customizable TupleHash parameters.
Factory for producing extendable output function (XOF) calculators.
Base class for the approved mode SignatureOperatorFactory implementations.
Status utility class - it has three methods on it, one for returning "isReady" status, one for a status message,
and one for the current module checksum.
Base class for the FIPS approved mode SymmetricKeyGenerator implementations.
Base class for the approved mode SymmetricOperatorFactory implementations.
Source class for approved implementations of AES based algorithms
Parameters for Triple-DES AEAD and MAC modes..
Triple-DES key generator.
Factory for producing FIPS Triple-DES key wrap/unwrap operators.
Factory for producing FIPS Triple-DES MAC calculators.
Factory for basic Triple-DES encryption/decryption operators.
General Triple-DES operator parameters.
General Triple-DES operator parameters.
Parameters for Triple-DES key wrap operators.
Error thrown on an unapproved operation.
Base class for the approved mode XOFOperatorFactory implementations.
An "entropy" provider which returns pre-defined data on request.
Class holding precomputation data for fixed-point multiplications.
A secure random that returns pre-seeded data to calls of nextBytes() or generateSeed().
BigInteger Source - in this case we expect requests for data that will be used
for BigIntegers.
Data Source - in this case we just expect requests for byte arrays.
Base class for sources of fixed "Randomness"
Base class for the marker/algorithm ids for non-FIPS algorithms.
Base class for parameter classes for algorithms allow for authentication using MACs.
Marker class for a digest algorithm
The GeneralName object.
The base class for parameter classes for non-FIPS algorithms.
Base class for parameter classes for algorithms that require an initialization vector or nonce.
Base class for DRBG/RNG SecureRandom implementations that use non-FIPS approved algorithms.
Class for containing a restriction object subtrees in NameConstraints.
Chinese standard GM named curves.
GNU project OID collection
Source class for implementations of GOST28147 based algorithms.
Factory for GOST28147 AEAD encryption/decryption operators.
Parameters for GOST28147 AEAD and MAC modes.
GOST28147 key generator.
Factory for producing GOST28147 MAC calculators.
Factory for basic GOST28147 encryption/decryption operators.
Parameters for general GOST28147 block cipher modes.
Gost28147-89-EncryptedKey ::= SEQUENCE {
encryptedKey Gost28147-89-Key,
maskKey [0] IMPLICIT Gost28147-89-Key
OPTIONAL,
macKey Gost28147-89-MAC
}
A parameter spec generating parameters for GOST-28147.
ASN.1 algorithm identifier parameters for GOST-28147
A parameter spec for the GOST-28147 cipher.
A parameter spec for the GOST-28147 cipher.
Source class for implementations of GOST3410 based algorithms.
GOST3410 key pair generation parameters.
GOST3410 key pair generator class.
Operator factory for creating GOST3410 based signing and verification operators.
Parameters for GOST3410 signatures.
Domain parameters for GOST R 34.10-1994.
ParameterSpec for a GOST 3410-94 key.
Main interface for a GOST keys.
table of the available named parameters for GOST 3410-94.
Generic base type for GOST R 34.10-1994 and GOST R 34.10-2001.
ParameterSpec for a GOST 3410-1994/2001/2012 algorithm parameters.
Interface that a GOST-3410 private key needs to conform to.
This class specifies a GOST3410-94 private key with its associated parameters.
Interface that a GOST-3410 public key needs to conform to.
This class specifies a GOST3410-94 public key with its associated parameters.
GostR3410-KeyTransport ::= SEQUENCE {
sessionEncryptedKey Gost28147-89-EncryptedKey,
transportParameters
[0] IMPLICIT GostR3410-TransportParameters OPTIONAL
}
GostR3410-TransportParameters ::= SEQUENCE {
encryptionParamSet OBJECT IDENTIFIER,
ephemeralPublicKey [0] IMPLICIT SubjectPublicKeyInfo OPTIONAL,
ukm OCTET STRING
}
Utility class for converting hex data to bytes and back again.
A streaming Hex encoder.
Converters for going from hex to binary and back.
The Holder object.
SP 800-56C Hybrid Value spec, to allow the secret in a key agreement to be
created as "Z | T" where T is some other secret value as described in Section 2.
IANA:
{ iso(1) identifier-organization(3) dod(6) internet(1) } == IETF defined things
Source class for implementations of IDEA based algorithms.
Factory for IDEA AEAD encryption/decryption operators.
Parameters for IDEA AEAD and MAC modes.
IDEA key generator.
Factory for producing IDEA MAC calculators.
Factory for basic IDEA encryption/decryption operators.
Parameters for general IDEA block cipher modes.
Implementation of
IetfAttrSyntax as specified by RFC3281.Exception thrown when an attempt is made to use an illegal key with an algorithm, A key
may be regarded as illegal if it has been created for a specific mode of a particular algorithm
and an attempt is made to use it for a different mode.
Interface implemented by objects that can be converted from streaming to in-memory objects.
Base interface for an input consuming AEAD Decryptor supporting associated text.
Base interface for an input consuming Decryptor.
Utility methods and constants for ints.
Exception thrown when something unexpected is encountered processing an encrypted stream.
Exception thrown when something unexpected is encountered in verifying a signature.
Exception thrown when an invalid key wrapping is encountered.
Utility methods for processing String objects containing IP addresses.
The Iso4217CurrencyCode object.
OIDS from ISO/IEC 10118-3:2004
IssuingDistributionPoint ::= SEQUENCE {
distributionPoint [0] DistributionPointName OPTIONAL,
onlyContainsUserCerts [1] BOOLEAN DEFAULT FALSE,
onlyContainsCACerts [2] BOOLEAN DEFAULT FALSE,
onlySomeReasons [3] ReasonFlags OPTIONAL,
indirectCRL [4] BOOLEAN DEFAULT FALSE,
onlyContainsAttributeCerts [5] BOOLEAN DEFAULT FALSE }
Utility class to allow use of Iterable feature in JDK 1.5+
Factory interface for instantiating JCA/JCE primitives.
Source class for non-FIPS key derivation functions (KDF).
Factory for scrypt KDFs.
Parameters for the scrypt key derivation function.
Parameters builder for the SCrypt key derivation function.
Interface describing a Key Derivation Function (KDF).
Interface describing a factory that creates Key Derivation Function (KDF) calculators.
Base interface for keys.
Base interface for a creator of a keyed extendable output function (XOF) calculators.
The KeyPurposeId object.
ASN.1 def for Diffie-Hellman key exchange KeySpecificInfo structure.
Base interface for a key un-wrapper.
Interface describing a KeyUnwrapper which also requires a SecureRandom as part of its configuration.
The KeyUsage object.
Base interface for a creator of key wrappers and un-wrappers.
Base interface for a key wrapper.
Interface describing a KeyWrapper which also requires a SecureRandom as part of its configuration.
Korea Information Security Agency (KISA)
({iso(1) member-body(2) kr(410) kisa(200004)})
KMACwithSHAKE128-params ::= SEQUENCE {
kMACOutputLength INTEGER DEFAULT 256, -- Output length in bits
customizationString OCTET STRING DEFAULT ''H
}
KMACwithSHAKE256-params ::= SEQUENCE {
kMACOutputLength INTEGER DEFAULT 512, -- Output length in bits
customizationString OCTET STRING DEFAULT ''H
}
KeySpec for use with secret key extraction with a SecretKeyFactory supporting KTS.
Builder class for creating a KTSExtractKeySpec.
KeySpec for use with secret key generation with a SecretKeyFactory supporting KTS.
Builder class for creating a KTSGenerateKeySpec.
Base KeySpec for creating the agreed key value in a KTS key exchange such as RSA-KEMs
Carrier class for a KTS secret key plus its encapsulation, as well as details about the MAC key if provided.
Base interface for a creator of secret value encapsulators and extractors.
Parameter spec for doing KTS based wrapping via the Cipher API.
Builder class for creating a KTSParameterSpec.
KeySpec for use with the RSA-KTS-KEM-KWS SecretKeyFactory.
The Bouncy Castle License.
Parameters for LMS/HSS key pair generation.
Operator factory for creating LMS based signing and verification operators.
ParameterSpec for keys using the LMS Hierarchical Signature System (HSS).
Base interface for Leighton-Micali Hash-Based Signatures (LMS) keys.
ParameterSpec for key generation for the Leighton-Micali Hash-Based Signature (LMS) scheme.
Base interface for an LMS private key
ASN.1 uses an EN locale for its internal formatting.
Utility methods and constants for longs.
Base interface for a creator of MAC calculators.
An output stream which calculates a MAC based on the data that is written to it.
Interface for Memoable objects.
Exception to be thrown on a failure to reset an object implementing Memoable.
General utility class for helping with MessageDigest.
Microsoft
The MonetaryValue object.
Parameter spec to provide MQV ephemeral keys and user keying material.
EC domain parameters associated with a specific object identifier.
JcaJceHelper that obtains all algorithms using a specific named provider.Structure for a name or pseudonym.
The NetscapeCertType object.
Utility class for fetching curves using their NIST names as published in FIPS-PUB 186-3
NIST:
iso/itu(2) joint-assign(16) us(840) organization(1) gov(101) csor(3)
NoticeReference class, used in
CertificatePolicies X509 V3 extensions
(in policy qualifiers).From RFC 3657
Use of the Camellia Encryption Algorithm
in Cryptographic Message Syntax (CMS)
ObjectData ::= SEQUENCE {
type INTEGER,
identifier UTF8String,
creationDate GeneralizedTime,
lastModifiedDate GeneralizedTime,
data OCTET STRING,
comment UTF8String OPTIONAL
}
ObjectDataSequence ::= SEQUENCE OF ObjectData
ObjectDigestInfo ASN.1 structure used in v2 attribute certificates.
ObjectStore ::= SEQUENCE {
CHOICE {
encryptedObjectStoreData EncryptedObjectStoreData,
objectStoreData ObjectStoreData
}
integrityCheck ObjectStoreIntegrityCheck
}
ObjectStoreData ::= SEQUENCE {
version INTEGER.
ObjectStoreIntegrityCheck ::= CHOICE {
PbkdMacIntegrityCheck
[0] EXPLICIT SignatureCheck
}
OCSP RFC 2560, RFC 6960
OCSP RFC 2560, RFC 6960
Class for breaking up an OID into it's component tokens, ala
java.util.StringTokenizer.
OIW organization's OIDs:
Base error class for errors that occur in the general classes.
Exception thrown if an operator has not been properly initialized.
Interface allowing an operator to be created with a particular SecureRandom.
ASN.1 def for Diffie-Hellman key exchange OtherInfo structure.
The OtherName object.
Base interface for an output producing AEAD Decryptor supporting associated text.
Base interface for an output producing AEAD Encryptor supporting associated text.
Base interface for a cipher which produces encrypted/decrypted output.
Base interface for an output producing Decryptor.
Base interface for a digest calculator.
Base interface for an output producing Encryptor.
Base interface for a MAC calculator.
Base interface for an output signer.
Interface for an output signer that can make use of a SecureRandom,
Interface for an output signer that also supports message recovery from the signature.
Utility class for creating OutputStreams from different JCA/JCE operators.
Base interface for an output validator which can be used to verify a data stream.
Interface for an output validator that also supports message recovery from the signature.
Base interface for an output verifier which can be used to verify a signature against a data stream.
Interface for an output verifier that also supports message recovery from the signature.
Base interface for an eXtendable Output Funnction (XOF) calculator.
Utility methods for converting byte arrays into ints and longs, and back again.
Base interface for operator parameters.
Interface describing parameters that have an initialization vector (IV) associated with them.
Base interface for a password based deriver of bytes for symmetric keys.
The target key type we are trying to produce a key for.
Base interface for a creator of password based key derivers.
Standard char[] to byte[] converters for password based derivation algorithms.
Source class for implementations of Password-Based Key Derivation Algorithms
Factory for password based key derivation functions.
Initial builder for OpenSSL
PBKD parameters.
Initial builder for general PBKD parameters.
A password based key for use with PBKDF1 as defined in PKCS#5.
A password based key for use with PBKDF1 as defined in PKCS#5 with full PBE parameters.
Configuration class for a PBKDF using PKCS#5 Scheme 2.
A password based key for use with PBKDF2 as defined in PKCS#5.
PBEKeySpec allowing for the use of alternate PRFs with PBKDF2.
A password based key for use with PBKDF2 as defined in PKCS#5 with full PBE parameters.
PBEParameterSpec allowing for the use of alternate PRFs with PBKDF2.
PBKDF2-params ::= SEQUENCE {
salt CHOICE {
specified OCTET STRING,
otherSource AlgorithmIdentifier {{PBKDF2-SaltSources}}
},
iterationCount INTEGER (1..MAX),
keyLength INTEGER (1..MAX) OPTIONAL,
prf AlgorithmIdentifier {{PBKDF2-PRFs}} DEFAULT algid-hmacWithSHA1 }
Base class for PBKDF configs.
Base interface for keys associated with various password based key derivation functions (PBKDF).
PbkdMacIntegrityCheck ::= SEQUENCE {
macAlgorithm AlgorithmIdentifier,
pbkdAlgorithm KeyDerivationFunc,
mac OCTET STRING
}
Exception thrown on failure to generate a PEM object.
Class representing a PEM header (name, value) pair.
A generic PEM object - type, header properties, and byte content.
Base interface for generators of PEM objects.
Base interface for parsers to convert PEM objects into specific objects.
A generic PEM reader, based on the format outlined in RFC 1421
A generic PEM writer, based on RFC 1421
Contains personal data for the otherName field in the subjectAltNames
extension.
the infamous Pfx from PKCS12
A password based key for use with PKCS#12.
A password based key for use with PKCS#12 with full PBE parameters.
LoadStoreParameter to allow for additional config with PKCS12 files.
pkcs-1 OBJECT IDENTIFIER ::=
Generic interface for a PKIX based certificate store.
This class is a Selector implementation for certificates.
Builder for a PKIXCertStoreSelector.
Generic interface for a PKIX based CRL store.
This class is a Selector implementation for X.509 certificate revocation
lists.
Builder for a PKIXCRLStoreSelector.
This class contains extended parameters for PKIX certification path builders.
Builder for a PKIXExtendedBuilderParameters object.
This class extends the PKIXParameters with a validity model parameter.
Builder for a PKIXExtendedParameters object.
Exception thrown when something unexpected is encountered processing plain text input data for signature or block encryption.
PKIX RFC 5280
PolicyMappings V3 extension, described in RFC3280.
PolicyQualifierId, used in the CertificatePolicies
X509V3 extension.
Policy qualifiers, used in the X509V3 CertificatePolicies
extension.
Interface for classes storing precomputation data for multiplication
algorithms.
Class for instancing AnnotatedPrivateKeys.
RFC 5958
PrivateKeyUsagePeriod ::= SEQUENCE {
notBefore [0] GeneralizedTime OPTIONAL,
notAfter [1] GeneralizedTime OPTIONAL }
Utility method for accessing system properties.
JcaJceHelper that obtains all algorithms from a specific Provider instance.This is designed to parse
the PublicKeyAndChallenge created by the KEYGEN tag included by
Mozilla based browsers.
The QCStatement object.
Utility class to convert decimal numbers (BigInteger) into a number in the base provided and the other way round.
Source class for implementations of RC2 based algorithms.
Factory for RC2 AEAD encryption/decryption operators.
Parameters for RC2 AEAD and MAC modes.
RC2 key generator.
Factory for RC2 key wrap/unwrap operators.
Factory for producing RC2 MAC calculators.
Factory for basic RC2 encryption/decryption operators.
Parameters for general RC2 block cipher modes.
Holding class for a single Relative Distinguished Name (RDN).
The ReasonFlags object.
Interface describing recovered message details from a signature.
OCSP RFC 2560, RFC 6960
OCSP RFC 2560, RFC 6960
Implementation of the RoleSyntax object as specified by the RFC3281.
Source class for non-FIPS implementations of RSA based algorithms.
Parameters for ISO 9796-2 PSS signature algorithms.
Parameters for ISO 9796-2 signature algorithms.
RSA key pair generation parameters for non-FIPS usages.
RSA key pair generator class for non-FIPS usages.
Factory for creating non-FIPS RSA key wrap/unwrap operators.
Parameters for use with non-FIPS RSA OAEP formatted key wrapping/unwrapping and encryption/decryption.
Factory for creating non-FIPS encryption/decryption operators.
Base class for RSA encryption/decryption and key wrap/unwrap parameters.
Parameters for use with non-FIPS RSA PKCS#1 v1.5 formatted key wrapping/unwrapping and encryption/decryption.
Parameters for PKCS#1 v1.5 signature algorithms.
Parameters for RSA PSS digest signatures.
Parameters for use with unformatted RSA encryption/decryption.
Operator factory for creating non-FIPS RSA based signing and verification operators.
Base class for non-FIPS RSA digest based signature algorithm parameters.
Operator factory for creating RSA based signing and verification operators which also offer message recovery.
Base class for parameters that can also be used for key wrapping.
Parameters for PKCS#1 v1.5 signature algorithms.
Basic unblinded RSA engine implementation.
Parent class for exceptions arising due to cryptographic operations in the various streams created by the FIPS factory classes.
Source class for scrypt utility KDF, an augmentation of the PBKDF2 PBE algorithm which incorporates a memory-hard component.
Factory for scrypt KDFs.
Parameters for the scrypt key derivation function.
Parameters builder for the scrypt key derivation function.
Configuration class for a PBKDF based around scrypt.
Key spec for use with the scrypt SecretKeyFactory.
RFC 7914 scrypt parameters.
Certicom object identifiers
SecretKeyData ::= SEQUENCE {
keyAlgorithm OBJECT IDENTIFIER,
keyBytes OCTET STRING
}
Interface describing secret with encapsulation details.
Source class for implementations of non-FIPS secure hash algorithms.
Parameters for HMAC modes.
HMAC key generator
Factory for producing HMAC calculators.
Factory for producing digest calculators.
Generic digest parameters.
Source provider for SecureRandom implementations.
The SEED encryption algorithm as described in RFC 4269.
Factory for SEED AEAD encryption/decryption operators.
Parameters for SEED AEAD and MAC modes.
SEED key generator.
Factory for SEED key wrap/unwrap operators.
Factory for producing SEED MAC calculators.
Factory for basic SEED encryption/decryption operators.
Parameters for general SEED block cipher modes.
SEED general WRAP operator parameters for KW and KWP.
Interface a selector from a store should conform to.
The SemanticsInformation object.
The Serpent encryption algorithm.
Factory for Serpent AEAD encryption/decryption operators.
Parameters for Serpent AEAD and MAC modes.
Serpent key generator.
Factory for Serpent key wrap/unwrap operators.
Factory for producing Serpent MAC calculators.
Factory for basic Serpent encryption/decryption operators.
Parameters for general Serpent block cipher modes.
Serpent key wrap/unwrap operator parameters for KW and KWP.
The SHACAL-2 encryption algorithm.
Factory for SHACAL-2 AEAD encryption/decryption operators.
Parameters for SHACAL-2 AEAD and MAC modes.
SHACAL-2 key generator.
Factory for producing SHACAL-2 MAC calculators.
Factory for basic SHACAL-2 encryption/decryption operators.
Parameters for general SHACAL-2 block cipher modes.
Utility methods and constants for shorts.
Object Identifiers of SigI specifciation (German Signature Law
Interoperability specification).
SignatureCheck ::= SEQUENCE {
signatureAlgorithm AlgorithmIdentifier,
certificates [0] EXPLICIT Certificates OPTIONAL,
signatureValue BIT STRING
}
Certificates ::= SEQUENCE OF Certificate
Interface describing an operator factory that produces signers and verifiers.
Interface describing an operator factory that produces signers and verifiers for
algorithms that support message recovery.
a PKCS#7 signed data object.
SignedPublicKeyAndChallenge ::= SEQUENCE {
publicKeyAndChallenge PublicKeyAndChallenge,
signatureAlgorithm AlgorithmIdentifier,
signature BIT STRING
}
a PKCS#7 signer info object.
Base interface for a cipher only able to handle a single block of data.
Base interface for a decryptor only able to decrypt a single block of data.
Interface for a decryptor only able to decrypt a single block of data that makes use of
a SecureRandom in the process (usually for algorithmic blinding).
Base interface for a encryptor only able to encrypt a single block of data.
Interface for a encryptor only able to encrypt a single block of data that makes use of
a SecureRandom in the process.
Source class for implementations of SipHash based algorithms
Parameters for SipHash MAC modes.
SipHash key generator.
Factory for producing SipHash MAC calculators.
A generic interface describing a simple store of objects.
Exception thrown if there's an issue doing a match in store.
Parent class for exceptions arising due to cryptographic operations in the various streams created by the FIPS factory classes.
Exception thrown when too much data is written to an InputStream
Utility methods to assist with stream processing.
An interface defining a list of strings.
String utilities.
X.509 Section 9.8.2.
This extension may contain further X.500 attributes of the subject.
The SubjectKeyIdentifier object.
The object that contains the public key stored in a certificate.
Interface describing a symmetric key.
Interface describing a symmetric key generator.
Interface describing an operator factory that creates operators for doing
encryption and decryption using symmetric ciphers.
Basic class describing a secret key implementation.
Target structure used in target information extension for attribute
certificates from RFC 3281.
Target information extension for attributes certificates according to RFC
3281.
Targets structure used in target information extension for attribute
certificates from RFC 3281.
The TBSCertificate object.
PKIX RFC-2459 - TBSCertList object.
An input stream which copies anything read through it to another stream.
An output stream which copies anything written into it to another stream.
Elliptic curves defined in "ECC Brainpool Standard Curves and Curve Generation"
https://www.ecc-brainpool.org/download/draft_pkix_additional_ecc_dp.txt
Object identifiers based on the TeleTrust branch.
A fixed secure random designed to return data for someone needing to create a single BigInteger.
A fixed secure random designed to return data for someone needing random bytes.
A class for returning "quick entropy" for testing purposes.
General interface for a translator.
Source class for non-FIPS approved-mode implementations of TripleDES based algorithms.
Factory for non-FIPS Triple-DES AEAD encryption/decryption operators.
Parameters for Triple-DES non-FIPS AEAD and MAC modes..
Specific Triple-DES key generator for non-FIPS algorithms.
Factory for non-FIPS Triple-DES key wrap/unwrap operators.
Factory for producing non-FIPS Triple-DES MAC calculators.
Factory for basic non-FIPS Triple-DES encryption/decryption operators.
Parameters for general Triple-DES non-FIPS block cipher modes.
Source class for implementations of Twofish based algorithms.
Factory for Twofish AEAD encryption/decryption operators.
Parameters for Twofish AEAD and MAC modes.
Twofish key generator.
Factory for Twofish key wrap/unwrap operators.
Factory for producing Twofish MAC calculators.
Factory for basic Twofish encryption/decryption operators.
Parameters for general Twofish block cipher modes.
General WRAP operator parameters for KW and KWP.
The TypeOfBiometricData object.
Ukrainian object identifiers
This is a testing utility class to check the property that an
OutputStream is never
closed in some particular context - typically when wrapped by another OutputStream that
should not be forwarding its OutputStream.close() calls.A runtime exception that may be thrown by an update operation on an
UpdateOutputStream if the underlying stream throws an IOException.
An extension of output stream that provides update methods which allow
for data to feed into the stream without the need to handle checked exceptions.
Convert binary data to and from UrlBase64 encoding.
Convert binary data to and from UrlBase64 encoding.
User keying material for the KDF used in key agreement algorithms.
UserNotice class, used in
CertificatePolicies X509 extensions (in policy
qualifiers).Utilities for working with UTF-8 encodings.
Generator for Version 1 TBSCertificateStructures.
Generator for Version 2 AttributeCertificateInfo
Generator for Version 2 TBSCertList structures.
Generator for Version 3 TBSCertificateStructures.
Diffie-Hellman domain validation parameters.
Class implementing the WNAF (Window Non-Adjacent Form) multiplication
algorithm.
Class holding precomputation data for the WNAF (Window Non-Adjacent Form)
algorithm.
Parameter spec to allow keywrapping to be configured to use the inverse function.
An output stream limited in size to the underlying byte array backing it.
Class implementing the WTNAF (Window
τ-adic Non-Adjacent Form) algorithm.Class holding precomputation data for the WTNAF (Window
τ-adic Non-Adjacent Form) algorithm.The X.500 Name object.
A builder class for making X.500 Name objects.
This interface provides a profile to conform to when
DNs are being converted into strings and back.
class for breaking up an X500 Name into it's component tokens, ala
java.util.StringTokenizer.
Source class for implementations of Pseudo Random Number Generator (PRNG) from X9.31
Base for Builder for SecureRandom objects based on the X9.31 PRNG.
Builder for SecureRandom objects based on the X9.31 PRNG.
Table of the current named curves defined in X.962 EC-DSA.
The Parameters ASN.1 CHOICE from X9.62.
ASN.1 def for Elliptic-Curve Curve structure.
ASN.1 def for Elliptic-Curve ECParameters structure.
A holding class that allows for X9ECParameters to be lazily constructed.
Class for describing an ECPoint as a DER object.
Class for processing an FieldElement as a DER object.
ASN.1 def for Elliptic-Curve Field ID structure.
A class which converts integers to byte arrays, allowing padding and calculations
to be done according the the filed size of the curve or field element involved.
Object identifiers for the various X9 standards.
Base interface for XDH agreement keys.
ParameterSpec for XDH key agreement algorithms.
Base interface for a creator of extendable output function (XOF) calculators.
Interface for SecretKey's that can be explictly zeroized.