/* * Copyright (c) 2000, 2006, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it * under the terms of the GNU General Public License version 2 only, as * published by the Free Software Foundation.  Oracle designates this * particular file as subject to the "Classpath" exception as provided * by Oracle in the LICENSE file that accompanied this code. * * This code is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License * version 2 for more details (a copy is included in the LICENSE file that * accompanied this code). * * You should have received a copy of the GNU General Public License version * 2 along with this work; if not, write to the Free Software Foundation, * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. * * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA * or visit www.oracle.com if you need additional information or have any * questions. */ package sun.security.jgss; import org.ietf.jgss.GSSException;import java.io.InputStream;import java.io.OutputStream;import java.io.IOException;import sun.security.util.*; /** * This class represents the mechanism independent part of a GSS-API * context establishment token. Some mechanisms may choose to encode * all subsequent tokens as well such that they start with an encoding * of an instance of this class. e.g., The Kerberos v5 GSS-API Mechanism * uses this header for all GSS-API tokens. * <p> * The format is specified in RFC 2743 section 3.1. * * @author Mayank Upadhyay */ /* * The RFC states that implementations should explicitly follow the * encoding scheme descibed in this section rather than use ASN.1 * compilers. However, we should consider removing duplicate ASN.1 * like code from here and depend on sun.security.util if possible. */ public class GSSHeader {     private ObjectIdentifier mechOid = null;    private byte[] mechOidBytes = null;    private int mechTokenLength = 0;     /**     * The tag defined in the GSS-API mechanism independent token     * format.     */    public static final int TOKEN_ID=0x60;     /**     * Creates a GSSHeader instance whose encoding can be used as the     * prefix for a particular mechanism token.     * @param mechOid the Oid of the mechanism which generated the token     * @param mechTokenLength the length of the subsequent portion that     * the mechanism will be adding.     */    public GSSHeader(ObjectIdentifier mechOid, int mechTokenLength)        throws IOException {         this.mechOid = mechOid;        DerOutputStream temp = new DerOutputStream();        temp.putOID(mechOid);        mechOidBytes = temp.toByteArray();        this.mechTokenLength = mechTokenLength;    }     /**     * Reads in a GSSHeader from an InputStream. Typically this would be     * used as part of reading the complete token from an InputStream     * that is obtained from a socket.     */    public GSSHeader(InputStream is)        throws IOException, GSSException {         //      debug("Parsing GSS token: ");         int tag = is.read();         //      debug("tag=" + tag);         if (tag != TOKEN_ID)            throw new GSSException(GSSException.DEFECTIVE_TOKEN, -1,                                   "GSSHeader did not find the right tag");         int length = getLength(is);         DerValue temp = new DerValue(is);        mechOidBytes = temp.toByteArray();        mechOid = temp.getOID();        //      debug (" oid=" + mechOid);         //      debug (" len starting with oid=" + length);        mechTokenLength = length - mechOidBytes.length;         //      debug("  mechToken length=" + mechTokenLength);     }     /**     * Used to obtain the Oid stored in this GSSHeader instance.     * @return the Oid of the mechanism.     */    public ObjectIdentifier getOid() {        return mechOid;    }     /**     * Used to obtain the length of the mechanism specific token that     * will follow the encoding of this GSSHeader instance.     * @return the length of the mechanism specific token portion that     * will follow this GSSHeader.     */    public int getMechTokenLength() {        return mechTokenLength;    }     /**     * Used to obtain the length of the encoding of this GSSHeader.     * @return the lenght of the encoding of this GSSHeader instance.     */    public int getLength() {        int lenField = mechOidBytes.length + mechTokenLength;        return (1 + getLenFieldSize(lenField) + mechOidBytes.length);    }     /**     * Used to determine what the maximum possible mechanism token     * size is if the complete GSSToken returned to the application     * (including a GSSHeader) is not to exceed some pre-determined     * value in size.     * @param mechOid the Oid of the mechanism that will generate     * this GSS-API token     * @param maxTotalSize the pre-determined value that serves as a     * maximum size for the complete GSS-API token (including a     * GSSHeader)     * @return the maximum size of mechanism token that can be used     * so as to not exceed maxTotalSize with the GSS-API token     */    public static int getMaxMechTokenSize(ObjectIdentifier mechOid,                                          int maxTotalSize) {         int mechOidBytesSize = 0;        try {            DerOutputStream temp = new DerOutputStream();            temp.putOID(mechOid);            mechOidBytesSize = temp.toByteArray().length;        } catch (IOException e) {        }         // Subtract bytes needed for 0x60 tag and mechOidBytes        maxTotalSize -= (1 + mechOidBytesSize);         // Subtract maximum len bytes        maxTotalSize -= 5;         return maxTotalSize;         /*         * Len field and mechanism token must fit in remaining         * space. The range of the len field that we allow is         * 1 through 5.         *          int mechTokenSize = 0;         for (int lenFieldSize = 1; lenFieldSize <= 5;         lenFieldSize++) {         mechTokenSize = maxTotalSize - lenFieldSize;         if (getLenFieldSize(mechTokenSize + mechOidBytesSize +         lenFieldSize) <= lenFieldSize)         break;         }          return mechTokenSize;        */      }     /**     * Used to determine the number of bytes that will be need to encode     * the length field of the GSSHeader.     */    private int getLenFieldSize(int len) {        int retVal = 1;        if (len < 128) {            retVal=1;        } else if (len < (1 << 8)) {            retVal=2;        } else if (len < (1 << 16)) {            retVal=3;        } else if (len < (1 << 24)) {            retVal=4;        } else {            retVal=5; // See getMaxMechTokenSize        }        return retVal;    }     /**     * Encodes this GSSHeader instance onto the provided OutputStream.     * @param os the OutputStream to which the token should be written.     * @return the number of bytes that are output as a result of this     * encoding     */    public int encode(OutputStream os) throws IOException {        int retVal = 1 + mechOidBytes.length;        os.write(TOKEN_ID);        int length = mechOidBytes.length + mechTokenLength;        retVal += putLength(length, os);        os.write(mechOidBytes);        return retVal;    }     /**     * Get a length from the input stream, allowing for at most 32 bits of     * encoding to be used. (Not the same as getting a tagged integer!)     *     * @return the length or -1 if indefinite length found.     * @exception IOException on parsing error or unsupported lengths.     */    // shameless lifted from sun.security.util.DerInputStream.    private int getLength(InputStream in) throws IOException {        return getLength(in.read(), in);    }     /**     * Get a length from the input stream, allowing for at most 32 bits of     * encoding to be used. (Not the same as getting a tagged integer!)     *     * @return the length or -1 if indefinite length found.     * @exception IOException on parsing error or unsupported lengths.     */    // shameless lifted from sun.security.util.DerInputStream.    private int getLength(int lenByte, InputStream in) throws IOException {        int value, tmp;         tmp = lenByte;        if ((tmp & 0x080) == 0x00) { // short form, 1 byte datum            value = tmp;        } else {                                         // long form or indefinite            tmp &= 0x07f;             /*             * NOTE:  tmp == 0 indicates indefinite length encoded data.             * tmp > 4 indicates more than 4Gb of data.             */            if (tmp == 0)                return -1;            if (tmp < 0 || tmp > 4)                throw new IOException("DerInputStream.getLength(): lengthTag="                                      + tmp + ", "                                      + ((tmp < 0) ? "incorrect DER encoding." : "too big."));             for (value = 0; tmp > 0; tmp --) {                value <<= 8;                value += 0x0ff & in.read();            }        }        return value;    }     /**     * Put the encoding of the length in the specified stream.     *     * @params len the length of the attribute.     * @param out the outputstream to write the length to     * @return the number of bytes written     * @exception IOException on writing errors.     */    // Shameless lifted from sun.security.util.DerOutputStream.    private int putLength(int len, OutputStream out) throws IOException {        int retVal = 0;        if (len < 128) {            out.write((byte)len);            retVal=1;         } else if (len < (1 << 8)) {            out.write((byte)0x081);            out.write((byte)len);            retVal=2;         } else if (len < (1 << 16)) {            out.write((byte)0x082);            out.write((byte)(len >> 8));            out.write((byte)len);            retVal=3;         } else if (len < (1 << 24)) {            out.write((byte)0x083);            out.write((byte)(len >> 16));            out.write((byte)(len >> 8));            out.write((byte)len);            retVal=4;         } else {            out.write((byte)0x084);            out.write((byte)(len >> 24));            out.write((byte)(len >> 16));            out.write((byte)(len >> 8));            out.write((byte)len);            retVal=5;        }         return retVal;    }     // XXX Call these two in some central class    private void debug(String str) {        System.err.print(str);    }     private  String getHexBytes(byte[] bytes, int len)        throws IOException {         StringBuffer sb = new StringBuffer();        for (int i = 0; i < len; i++) {             int b1 = (bytes[i]>>4) & 0x0f;            int b2 = bytes[i] & 0x0f;             sb.append(Integer.toHexString(b1));            sb.append(Integer.toHexString(b2));            sb.append(' ');        }        return sb.toString();    }}