An implementation of outgoing messages for use with key agreement * protocols.
*/ public class OutgoingMessage { // Constants and variables // ------------------------------------------------------------------------- /** The internal output stream. */ private ByteArrayOutputStream out; // Constructor(s) // ------------------------------------------------------------------------- public OutgoingMessage() { super(); out = new ByteArrayOutputStream(); } // Class methods // ------------------------------------------------------------------------- // Instance methods // ------------------------------------------------------------------------- /** *Returns the encoded form of the current message including the 4-byte * length header.
* * @throws KeyAgreementException if an encoding size constraint is violated. */ public byte[] toByteArray() throws KeyAgreementException { byte[] buffer = wrap(); int length = buffer.length; byte[] result = new byte[length + 4]; result[0] = (byte) (length >>> 24); result[1] = (byte) (length >>> 16); result[2] = (byte) (length >>> 8); result[3] = (byte) length; System.arraycopy(buffer, 0, result, 4, length); return result; } /** *Returns the encoded form of the current message excluding the 4-byte * length header.
* * @throws KeyAgreementException if an encoding size constraint is violated. */ public byte[] wrap() throws KeyAgreementException { int length = out.size(); if (length > Registry.SASL_BUFFER_MAX_LIMIT || length < 0) { throw new KeyAgreementException("message content is too long"); } return out.toByteArray(); } /** * Encodes a public key into the message. ** When a public key is encoded into an outgoing message, the byte array of * the encoded key --according to its encoding/decoding format specified when * the key was first instantiated-- are put in the message (a) preceeded by * one byte representing both the type of key (upper 4-bit) and the identifier * of the format used (lower 4-bit), and (b) preceeed by a 4-byte entity * representing the total length, excluding these 4 bytes, of the bytes * representing the encoded key and the one-byte representing the key-type and * format; i.e. * *
* key --> 4-byte-length || 1-byte-type-and-format || encoded-key-bytes ** * @param k the public key to encode. * @throws KeyAgreementException if an encoding size constraint is violated. */ public void writePublicKey(PublicKey k) throws KeyAgreementException { writeKey(k); } /** * Encodes a private key into the message. *
* When a private key is encoded into an outgoing message, the byte array of * the encoded key --according to its encoding/decoding format specified when * the key was first instantiated-- are put in the message (a) preceeded by * one byte representing both the type of key (upper 4-bit) and the identifier * of the format used (lower 4-bit), and (b) preceeed by a 4-byte entity * representing the total length, excluding these 4 bytes, of the bytes * representing the encoded key and the one-byte representing the key-type and * format; i.e. * *
* key --> 4-byte-length || 1-byte-type-and-format || encoded-key-bytes ** * @param k the private key to encode. * @throws KeyAgreementException if an encoding size constraint is violated. */ public void writePrivateKey(PrivateKey k) throws KeyAgreementException { writeKey(k); } /** *
Encodes an MPI into the message.
* * @param val the MPI to encode. * @throws KeyAgreementException if an encoding size constraint is violated. */ public void writeMPI(BigInteger val) throws KeyAgreementException { byte[] b = val.toByteArray(); int length = b.length; if (length > Registry.SASL_TWO_BYTE_MAX_LIMIT) { throw new KeyAgreementException("MPI is too long"); } byte[] lengthBytes = { (byte) (length >>> 8), (byte) length }; out.write(lengthBytes, 0, 2); out.write(b, 0, b.length); } /** *Encodes a string into the message.
* * @param s the string to encode. * @throws KeyAgreementException if the UTF8 encoding is not supported on * this platform, or if an encoding size constraint is violated. */ public void writeString(String s) throws KeyAgreementException { byte[] b = null; try { b = s.getBytes("UTF8"); } catch (UnsupportedEncodingException x) { throw new KeyAgreementException("unxupported UTF8 encoding", x); } int length = b.length; if (length > Registry.SASL_TWO_BYTE_MAX_LIMIT) { throw new KeyAgreementException("text too long"); } byte[] lengthBytes = { (byte) (length >>> 8), (byte) length }; out.write(lengthBytes, 0, 2); out.write(b, 0, b.length); } /** * @param k the key to encode. * @throws KeyAgreementException if an encoding size constraint is violated. */ private void writeKey(Key k) throws KeyAgreementException { byte[] b = k.getEncoded(); int keyType = getKeyType(k); int formatID = FormatUtil.getFormatID(k.getFormat()); int length = b.length + 1; if (length > Registry.SASL_FOUR_BYTE_MAX_LIMIT) throw new KeyAgreementException("Encoded key is too long"); byte[] lengthBytes = { (byte) (length >>> 24), (byte) (length >>> 16), (byte) (length >>> 8), (byte) length }; out.write(lengthBytes, 0, 4); out.write(((keyType & 0x0F) << 4) | (formatID & 0x0F)); out.write(b, 0, b.length); } /** * @param k the key to find an identifier for. * @return an integer from0 to 3 identifying
* the type of key.
* @throws KeyAgreementException if the designated key is of unknown or
* unsupported type.
*/
private int getKeyType(Key k) throws KeyAgreementException
{
if (k instanceof DSSKey)
return 0;
if (k instanceof GnuRSAKey)
return 1;
if (k instanceof GnuDHKey)
return 2;
if (k instanceof SRPKey)
return 3;
throw new KeyAgreementException("Unknown or unsupported key type: "
+ k.getClass().getName());
}
}