Docjar: A Java Source and Docuemnt Enginecom.*    java.*    javax.*    org.*    all    new    plug-in

Quick Search    Search Deep

javax.crypto.interfaces.* (4)javax.crypto.spec.* (12)

javax.crypto: Javadoc index of package javax.crypto.


Package Samples:

javax.crypto.interfaces
javax.crypto.spec

Classes:

CipherSpi: This class represents the Service Provider Interface ( SPI ) for cryptographic ciphers. Providers of cryptographic ciphers must subclass this for every cipher they implement, implementing the abstract methods as appropriate, then provide an entry that points to the subclass in their implementation of java.security.Provider . CipherSpi objects are instantiated along with Cipher s when the Cipher.getInstance(java.lang.String) 55 methods are invoked. Particular ciphers are referenced by a transformation , which is a String consisting of the cipher's name or the ciper's name followed by a mode and ...
Cipher: This class implements a cryptographic cipher for transforming data. Ciphers cannot be instantiated directly; rather one of the getInstance must be used to instantiate a given transformation , optionally with a specific provider. A transformation is of the form: algorithm / mode / padding , or algorithm where algorithm is the base name of a cryptographic cipher (such as "AES"), mode is the abbreviated name of a block cipher mode (such as "CBC" for cipher block chaining mode), and padding is the name of a padding scheme (such as "PKCS5Padding"). If only the algorithm name is supplied, then the provider-specific ...
SealedObject: This class allows any java.io.Serializable object to be stored in an encrypted form. When the sealed object is ready to be unsealed (and deserialized) the caller may use either getObject(javax.crypto.Cipher) 55 , which uses an already-initialized Cipher . or, getObject(java.security.Key) 55 or getObject(java.security.Key,java.lang.String) 55 , which will initialize a new cipher instance with the encodedParams 55 that were stored with this sealed object (this is so parameters, such as the IV, don't need to be known by the one unsealing the object).
SecretKey: A secret key for symmetric cryptography. This interface defines no new methods over java.security.Key , but rather is intended to be a marker interface and to provide type safety for secret keys. The format of secret keys should be RAW , as returned by Key.getFormat() > Key.getFormat() 55 . Concrete implementations of this interface should override the Object.equals(java.lang.Object) > Object.equals(java.lang.Object) 55 and Object.hashCode() > Object.hashCode() 55 methods of java.lang.Object to use the actual key data rather than the identity-based default methods.
Mac: This class implements a "message authentication code" (MAC), a method to ensure the integrity of data transmitted between two parties who share a common secret key. The best way to describe a MAC is as a keyed one-way hash function , which looks like: D = MAC(K, M) where K is the key, M is the message, and D is the resulting digest. One party will usually send the concatenation M || D to the other party, who will then verify D by computing D' in a similar fashion. If D == D' , then the message is assumed to be authentic.
EncryptedPrivateKeyInfo: An implementation of the EncryptedPrivateKeyInfo ASN.1 type as specified in PKCS #8 - Private-Key Information Syntax Standard . The ASN.1 type EncryptedPrivateKeyInfo is: EncryptedPrivateKeyInfo ::= SEQUENCE { encryptionAlgorithm EncryptionAlgorithmIdentifier, encryptedData EncryptedData } EncryptionAlgorithmIdentifier ::= AlgorithmIdentifier EncrytpedData ::= OCTET STRING AlgorithmIdentifier ::= SEQUENCE { algorithm OBJECT IDENTIFIER, parameters ANY DEFINED BY algorithm OPTIONAL }
KeyAgreement: Key agreement is a method in which two or more parties may agree on a secret key for symmetric cryptography or message authentication without transmitting any secrets in the clear. Key agreement algorithms typically use a public/private key pair , and the public key (along with some additional information) is sent across untrusted networks. The most common form of key agreement used today is the Diffie-Hellman key exchange algorithm , described in PKCS #3 - Diffie Hellman Key Agreement Standard .
MacSpi: This is the Service Provider Interface ( SPI ) for the Mac class. Providers wishing to implement a Mac must subclass this class and provide appropriate implementations of all its abstract methods, then provide an entry pointing to this implementation in the master java.security.Provider class. Implementations may optionally implement the java.lang.Cloneable interface.
KeyAgreementSpi: This is the Service Provider Interface ( SPI ) for the KeyAgreement class. Providers wishing to implement a key agreement algorithm must subclass this and provide an appropriate implementation for all the abstract methods below, and provide an appropriate entry in the master java.security.Provider class (the service name for key agreement algorithms is "KeyAgreement" ).
SecretKeyFactorySpi: The Service Provider Interface ( SPI ) for the SecretKeyFactory class. Providers wishing to implement a secret key factory must subclass this and provide an appropriate implementation for all the abstract methods below, and provide an appropriate entry in the master java.security.Provider class (the service name for secret key factories is "SecretKeyFactory" ).
KeyGeneratorSpi: The Service Provider Interface ( SPI ) for the KeyGenerator class. Providers wishing to implement a key generator must subclass this and provide an appropriate implementation for all the abstract methods below, and provide an appropriate entry in the master java.security.Provider class (the service name for key generators is "KeyGenerator" ).
SecretKeySpec: This is a simple wrapper around a raw byte array, for ciphers that do not require any key parameters other than the bytes themselves. Since this class implements javax.crypto.SecretKey , which in turn extends java.security.Key , so instances of this class may be passed directly to the init() methods of javax.crypto.Cipher .
SecretKeyFactory: A secret key factory translates SecretKey objects to and from java.security.spec.KeySpec objects, and can translate between different vendors' representations of SecretKey objects (for security or semantics; whichever applies).
DHParameterSpec: The base set of parameters necessary to perform Diffie-Hellman key exchange. Each party in the key exchange shares these parameters. Each set of parameters consists of a base generator g , a prime modulus p , and an optional length, in bits, of the private exponent. See PKCS #3 - Diffie-Hellman Key Agreement Standard for more information.
PBEKeySpec: A wrapper for a password-based key, used for password-based encryption (PBE). Examples of password-based encryption algorithms include: PKCS #5 - Password-Based Cryptography Standard PKCS #12 - Personal Information Exchange Syntax Standard
DHPrivateKey: This interface marks a private key in the Diffie-Hellman key exchange algorithm. It should be treated with as much care as any java.security.PrivateKey . Implementations of Diffie-Hellman private keys should implement this interface. Applications that know a particular key is a Diffie-Hellman private key can safely cast it to this interface.
ExemptionMechanism: An exemption mechanism, which will conditionally allow cryptography where it is not normally allowed, implements things such as key recovery , key weakening , or key escrow . Implementation note : this class is present for API-compatibility only; it is not actually used anywhere in this library and this library does not, in general, support crypto weakening.
CipherInputStream: This is an java.io.InputStream that filters its data through a Cipher before returning it. The Cipher argument must have been initialized before it is passed to the constructor.
DHPublicKey: This interface marks a public key in the Diffie-Hellman key-exchange algorithm. Implementations of Diffie-Hellman public keys should implement this interface. Applications that know that a particular key is a Diffie-Hellman public key it can be safely cast to this interface.
PBEKey: Interface to a password-derived key for password-based encryption (PBE). Applications working with a javax.crypto.SecretKey that is known to be a password-based key can safely cast such keys to this interface.
DHKey: This interface marks public/private keys in the Diffie-Hellman key exchange algorithm. Implementations of Diffie-Hellman keys should implement this interface, and applications can safely cast keys that are known to be Diffie-Hellman keys to this interface.
NullCipherSpi: Implements the identity cipher. Encrypting and decrypting do not alter the data. The NullCipher has a block size of 1. This class does not belong in the API, it should reside a a provider. Let's hope that Javasoft fixes this in a future release.
RC2ParameterSpec: A wrapper for parameters for the RC2 block cipher ("RC" means either "Rivest Cipher" or "Ron's Code", depending upon who you ask and when).
CipherOutputStream: A filtered output stream that transforms data written to it with a Cipher before sending it to the underlying output stream.
NullCipher: Trivial subclass of Cipher that implements the identity transformation , where the input is always copied to the output unchanged. Null ciphers can be instantiated with the public constructor.

Home | Contact Us | Privacy Policy | Terms of Service