| Home >> All >> cryptix >> [ openpgp Javadoc ] |
| • | cryptix.openpgp.algorithm.* (17) | • | cryptix.openpgp.examples.* (23) | • | cryptix.openpgp.io.* (23) |
| • | cryptix.openpgp.net.* (4) | • | cryptix.openpgp.packet.* (29) | • | cryptix.openpgp.provider.* (29) |
| • | cryptix.openpgp.signature.* (17) | • | cryptix.openpgp.test.* (27) | • | cryptix.openpgp.util.* (9) |
• cryptix.openpgp: Javadoc index of package cryptix.openpgp.
Package Samples:
• cryptix.openpgp.test
• cryptix.openpgp.test.algorithm
• cryptix.openpgp.test.all
• cryptix.openpgp.test.interop
• cryptix.openpgp.test.io
• cryptix.openpgp.test.net
• cryptix.openpgp.test.packet
• cryptix.openpgp.test.pki
• cryptix.openpgp.test.provider
• cryptix.openpgp.test.utf8
• cryptix.openpgp.test.util
• cryptix.openpgp.algorithm
• cryptix.openpgp.io
• cryptix.openpgp.net
• cryptix.openpgp.packet
• cryptix.openpgp.provider
• cryptix.openpgp.signature
• cryptix.openpgp.util
• cryptix.openpgp.examples
Classes:
• PGPMPI: Read and write BigIntegers in a PGP compatible format. From RFC 2440 : 3.2. Multi-Precision Integers Multi-Precision Integers (also called MPIs) are unsigned integers used to hold large integers such as the ones used in cryptographic calculations. An MPI consists of two pieces: a two-octet scalar that is the length of the MPI in bits followed by a string of octets that contain the actual integer. These octets form a big-endian number; a big-endian number can be made into an MPI by prefixing it with the appropriate length. Examples: (all numbers are in hexadecimal) The string of octets [00 01 01] ...
• PGPMarkerPacket: The marker packet. RFC 2440 says: 5.8. Marker Packet (Obsolete Literal Packet) (Tag 10) An experimental version of PGP used this packet as the Literal packet, but no released version of PGP generated Literal packets with this tag. With PGP 5.x, this packet has been re-assigned and is reserved for use as the Marker packet. The body of this packet consists of: - The three octets 0x50, 0x47, 0x50 (which spell "PGP" in UTF-8). Such a packet MUST be ignored when received. It may be placed at the beginning of a message that uses features not available in PGP 2.6.x in order to cause that version to report ...
• PGPLengthDataOutputStream: Generic outputstream to write PGP formatted packet data that contains length information This class basically has two modes, one where the length of the written data is (partly) known in advance and one when the length is not known. In the first mode all data will be written to the underlying outputstream immediately, which allows for full streaming. In the second mode all output will be buffered until the close method is called, where all data is then written in one big chunk to the outputstream. If the subclass wants, it can support writing data in chunks. This is particularly useful when in ...
• PGPAlgorithmFactory: Factory for public key, string-to-key, compression, hash and cipher algorithms. In a normal PGP application, the programmer probably does not have to deal with this class that much. The only thing he or she has to do is initialize it with the default values and just use the get methods to translate an algorithm ID into an implementation for that algorithm. The default implementation provides values for all algorithms that are mentioned in RFC2440. It's real strength however is it's ability to register additional algorithms. For example, once the AES has been chosen (and the maintainer is a bit ...
• PGPKeyServer: A generic, client interface to a key server. A key server allows for keys to be retrieved by some identifying value. PGPKeyServer keyserver = new Hkp("keyserver.pgp.com", 80); try { Collection keys = keyserver.fetchById("user@cryptix.org"); if (keys.size() > 0) { for(Iterator i = keys.iterator(); i.hasNext(); ) { KeyBundleMessage msg = (KeyBundleMessage) i.next(); KeyBundle key = msg.getKeyBundle(); // do something with the key } } } catch(KeyServerIOException e) { // handle server down or other low level problem. } catch(MessageException e) { // handle key server message format error. }
• PGPBase64: This class provides methods for encoding and decoding data in MIME base64 format. The input to the encode methods is always a byte array. Strictly speaking the output represents a sequence of characters, but since these characters are from a subset of both the Unicode and ASCII character repertoires, it is possible to express the output either as a String or as a byte array. References: RFC 2045, Multipurpose Internet Mail Extensions (MIME) Part One, Format of Internet Message Bodies , "Section 6.8 Base64 Content-Transfer-Encoding," http://www.imc.org/rfc2045
• PGPOnePassSignaturePacket: A class representing a one-pass signature packet. This packet both has a binary and a plaintext form. While RFC 2440 only lists the binary form of this packet, we also support the 'Hash:' armour header key in clearsigned messages. Because the plaintext form contains less information than the binary form, not all get methods will work with the plaintext form, in fact only the getHashID and the isNested method work. Fortunately these two are also the only useful ones for one pass signatures, so applications are encouraged not to depend on the other information contained in a binary one-pass signature ...
• PGPKeyServerImpl: This class embodies an interface layer between the client-oriented PGPKeyServer API and the individual classes that actually access key servers over the network. This class needs to be understood by those that want to write code to access a key server, it can be ignored by those who just want to use a keyserver using one of the pre-existing classes. Subclasses of this class know how to access a keyserver and return ascii-armored key data. All subclasses must: Implement the fetchRaw method. Call the constructor for this class in their constructor.
• PGPLengthDataInputStream: Generic inputstream to read PGP formatted packet data that contains length information This class contains generic methods for reading from PGP formatted data. It makes sure that no more bytes can be read then there are in the packet. A special feature of this class is that it supports data that is cut into multiple chunks, like the partial length packet bodies that can be used in V4 packets. It will transparently call initNewChunk every time it runs out of bytes, such that the class using this stream will think it deals with one big chunk of data.
• PGPUpdateable: Interface for classes that have an 'update' method This class was created, because cryptix.openpgp.io.PGPHashDataOutputStream needs access to the update(..) method of a cryptix.openpgp.algorithm.PGPSigner class. Because cryptix.openpgp.io is compiled before cryptix.openpgp.algorithm, the PGPSigner class can't be used directly, therefore this interface was created in the .util package, which is always compiled before .io and .algorithm. Changing compiling order would not have worked, because the classes in .algorithm use classes in .io
• PGPFlagsSP: Generic superclass for signature subpackets that contain flags Subclasses of this class should implement methods to control the individual flags, using the setFlag and getFlag methods. Note that this class is very flexible in resizing on demand. If a flag is set in the second byte, when only one byte is present, the second byte will be added and the flag set. The same for getting a flag: if the byte containing the flag is not available, it is added and filled with zero's.
• PGPCompressorOutputStream: This class provides a compression output stream framework. A compression output stream compresses data as it passes through the stream. For the most part, clients can treat this just like any other OutputStream, but they should call finish() when no more data will be written. Subclassors must implement writeInternal . Subclassors may want to override finishInternal to take care of any end-of-data processing.
• PGPCompressorInputStream: This class provides an expansion output stream framework. An expansion stream is one that expands data as it is read from an input stream. Clients can treat this just like any other InputStream. This class is really just like a FilterOutputStream, but does define all the read methods in terms of the framework method, readInternal. That is the only method that subclasses need to implement.
• PGPContainerPacket: The PGPContainerPacket provides (or will provide) an infrastructure for an ordered list of packets. This class holds the collection of "subpackets". Subclasses can use the encodeSubPackets method to call encode() recursively on the subpackets. And, for the decoding, clients can use devodeSubPackets to take packets out of a stream and place them in this collection.
• PGPNotationDataSP: Represents a signature subpacket containing a a "notation" on the signature that the issuer wishes to make. The notation has a name and a value, each of which are strings. There is also a flag that specifies that the information is human-readable. This class is used to represent the following default packets: 20 = notation data
• PGPCompressedDataPacket: "The Compressed Data packet contains compressed data. Typically, this packet is found as the contents of an encrypted packet, or following a Signature or One-Pass Signature packet, and contains literal data packets." -- RFC2440 To use this class for encoding a packet, you must set the compression algorithm ID manually via the setAlgorithmID method.
• PGPInputStreamAdapter: An adapter class that converts a PGPPacketDataInputStream into a java.io.InputStream. There is some hand waving going on here since a PGPPacketDataInputStream does not support the full suite of InputStream functionality, and it also throws some different exceptions (the PGPDataFormat ones) that the InputStream interface does not support.
• PGPCompressedDataPacketTest: PGPCompressedDataPacketTest (Copyright 2001 Cryptix Foundation) This class performs unit tests on cryptix.openpgp.packet.PGPCompressedDataPacket Explanation about the tested class and its responsibilities Relations: PGPCompressedDataPacket extends cryptix.openpgp.packet.PGPContainerPacket
• PGPUserIDPrincipalBuilderTest: PGPUserIDPrincipalBuilderTest (Copyright 2001 Cryptix Foundation) This class performs unit tests on cryptix.openpgp.provider.PGPUserIDPrincipalBuilder Explanation about the tested class and its responsibilities Relations: PGPUserIDPrincipalBuilder extends cryptix.pki.PrincipalBuilderSpi
• PGPCompressor: The PGPCompressor offers users an interface to compression and expansion streams. The actual compression routines used depend on the implementation. In addition to the methods listed in this interface, conforming implementations must have a no-argument constructor (this is required by the PGPAlgorithmFactory).
• PGPDSATest: PGPDSATest (Copyright 2001 Cryptix Foundation) This class performs unit tests on cryptix.openpgp.algorithm.PGPDSA Explanation about the tested class and its responsibilities Relations: PGPDSA extends java.lang.Object PGPDSA implements cryptix.openpgp.algorithm.PGPSigner
• PGPSignatureSubPacket: Generic superclass for all Signature Subpackets. Every subclass must implement the decodeBody and encodeBody methods. This class then handles the packaging into a real packet (Basically this means that this class takes care of the type byte and length). Every subclass must also implement the equals method.
• Hkp: This class looks up keys by some key identifier in a HKP key server. HKP stands for "Horowitz Key Protocol" which is just a fancy name for a very simple HTTP GET request. Such as it is, the protocol is documented here: http://www.mit.edu/afs/net.mit.edu/project/pks/thesis/paper/thesis.html
• CreateKeyRing: Detailed example for creating four keyrings based on the keys generated by the GenerateAndWriteKey example. Both Alice and Bob will get two keyrings: one public and one secret keyring. Their public keyrings will contain both public keys, while their secret keyrings obviously only holds their own key.
• ReadKeyRingSignKey: Detailed example for creating four keyrings based on the keys generated by the GenerateAndWriteKey example. Both Alice and Bob will get two keyrings: one public and one secret keyring. Their public keyrings will contain both public keys, while their secret keyrings obviously only holds their own key.
| Home | Contact Us | Privacy Policy | Terms of Service |