[BACK]Return to bufaux.c CVS log [TXT][DIR] Up to [local] / src / usr.bin / ssh

Annotation of src/usr.bin/ssh/bufaux.c, Revision 1.13

1.1       deraadt     1: /*
1.6       deraadt     2:  * Author: Tatu Ylonen <ylo@cs.hut.fi>
                      3:  * Copyright (c) 1995 Tatu Ylonen <ylo@cs.hut.fi>, Espoo, Finland
                      4:  *                    All rights reserved
1.13    ! deraadt     5:  * Auxiliary functions for storing and retrieving various data types to/from
        !             6:  * Buffers.
1.11      markus      7:  *
1.13    ! deraadt     8:  * As far as I am concerned, the code I have written for this software
        !             9:  * can be used freely for any purpose.  Any derived versions of this
        !            10:  * software must be clearly marked as such, and if the derived work is
        !            11:  * incompatible with the protocol description in the RFC file, it must be
        !            12:  * called by a name other than "ssh" or "Secure Shell".
1.11      markus     13:  *
1.6       deraadt    14:  *
1.9       markus     15:  * SSH2 packet format added by Markus Friedl
1.13    ! deraadt    16:  * Copyright (c) 2000 Markus Friedl.  All rights reserved.
1.9       markus     17:  *
1.13    ! deraadt    18:  * Redistribution and use in source and binary forms, with or without
        !            19:  * modification, are permitted provided that the following conditions
        !            20:  * are met:
        !            21:  * 1. Redistributions of source code must retain the above copyright
        !            22:  *    notice, this list of conditions and the following disclaimer.
        !            23:  * 2. Redistributions in binary form must reproduce the above copyright
        !            24:  *    notice, this list of conditions and the following disclaimer in the
        !            25:  *    documentation and/or other materials provided with the distribution.
        !            26:  *
        !            27:  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
        !            28:  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
        !            29:  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
        !            30:  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
        !            31:  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
        !            32:  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
        !            33:  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
        !            34:  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
        !            35:  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
        !            36:  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
1.6       deraadt    37:  */
1.1       deraadt    38:
                     39: #include "includes.h"
1.13    ! deraadt    40: RCSID("$OpenBSD: bufaux.c,v 1.12 2000/06/20 01:39:39 markus Exp $");
1.1       deraadt    41:
                     42: #include "ssh.h"
1.10      markus     43: #include <openssl/bn.h>
1.1       deraadt    44: #include "bufaux.h"
                     45: #include "xmalloc.h"
                     46: #include "getput.h"
                     47:
1.6       deraadt    48: /*
                     49:  * Stores an BIGNUM in the buffer with a 2-byte msb first bit count, followed
                     50:  * by (bits+7)/8 bytes of binary data, msb first.
                     51:  */
1.2       provos     52: void
                     53: buffer_put_bignum(Buffer *buffer, BIGNUM *value)
1.1       deraadt    54: {
1.5       markus     55:        int bits = BN_num_bits(value);
                     56:        int bin_size = (bits + 7) / 8;
1.8       markus     57:        char unsigned *buf = xmalloc(bin_size);
1.5       markus     58:        int oi;
                     59:        char msg[2];
                     60:
                     61:        /* Get the value of in binary */
                     62:        oi = BN_bn2bin(value, buf);
                     63:        if (oi != bin_size)
                     64:                fatal("buffer_put_bignum: BN_bn2bin() failed: oi %d != bin_size %d",
                     65:                      oi, bin_size);
                     66:
                     67:        /* Store the number of bits in the buffer in two bytes, msb first. */
                     68:        PUT_16BIT(msg, bits);
                     69:        buffer_append(buffer, msg, 2);
                     70:        /* Store the binary data. */
1.8       markus     71:        buffer_append(buffer, (char *)buf, oi);
1.7       markus     72:
1.5       markus     73:        memset(buf, 0, bin_size);
                     74:        xfree(buf);
1.1       deraadt    75: }
                     76:
1.6       deraadt    77: /*
                     78:  * Retrieves an BIGNUM from the buffer.
                     79:  */
1.2       provos     80: int
                     81: buffer_get_bignum(Buffer *buffer, BIGNUM *value)
1.1       deraadt    82: {
1.5       markus     83:        int bits, bytes;
                     84:        unsigned char buf[2], *bin;
1.1       deraadt    85:
1.5       markus     86:        /* Get the number for bits. */
                     87:        buffer_get(buffer, (char *) buf, 2);
                     88:        bits = GET_16BIT(buf);
                     89:        /* Compute the number of binary bytes that follow. */
                     90:        bytes = (bits + 7) / 8;
                     91:        if (buffer_len(buffer) < bytes)
                     92:                fatal("buffer_get_bignum: input buffer too small");
1.8       markus     93:        bin = (unsigned char*) buffer_ptr(buffer);
1.5       markus     94:        BN_bin2bn(bin, bytes, value);
                     95:        buffer_consume(buffer, bytes);
1.2       provos     96:
1.5       markus     97:        return 2 + bytes;
1.1       deraadt    98: }
                     99:
1.6       deraadt   100: /*
1.9       markus    101:  * Stores an BIGNUM in the buffer in SSH2 format.
                    102:  */
                    103: void
                    104: buffer_put_bignum2(Buffer *buffer, BIGNUM *value)
                    105: {
                    106:        int bytes = BN_num_bytes(value) + 1;
                    107:        unsigned char *buf = xmalloc(bytes);
                    108:        int oi;
                    109:        int hasnohigh = 0;
                    110:        buf[0] = '\0';
                    111:        /* Get the value of in binary */
                    112:        oi = BN_bn2bin(value, buf+1);
                    113:        if (oi != bytes-1)
                    114:                fatal("buffer_put_bignum: BN_bn2bin() failed: oi %d != bin_size %d",
                    115:                      oi, bytes);
                    116:        hasnohigh = (buf[1] & 0x80) ? 0 : 1;
                    117:        if (value->neg) {
                    118:                /**XXX should be two's-complement */
                    119:                int i, carry;
                    120:                unsigned char *uc = buf;
                    121:                log("negativ!");
                    122:                for(i = bytes-1, carry = 1; i>=0; i--) {
                    123:                        uc[i] ^= 0xff;
                    124:                        if(carry)
                    125:                                carry = !++uc[i];
                    126:                }
                    127:        }
                    128:        buffer_put_string(buffer, buf+hasnohigh, bytes-hasnohigh);
                    129:        memset(buf, 0, bytes);
                    130:        xfree(buf);
                    131: }
                    132:
                    133: int
                    134: buffer_get_bignum2(Buffer *buffer, BIGNUM *value)
                    135: {
                    136:        /**XXX should be two's-complement */
                    137:        int len;
                    138:        unsigned char *bin = (unsigned char *)buffer_get_string(buffer, (unsigned int *)&len);
                    139:        BN_bin2bn(bin, len, value);
                    140:        xfree(bin);
                    141:        return len;
                    142: }
                    143:
                    144: /*
1.6       deraadt   145:  * Returns an integer from the buffer (4 bytes, msb first).
                    146:  */
1.11      markus    147: unsigned int
1.5       markus    148: buffer_get_int(Buffer *buffer)
1.1       deraadt   149: {
1.5       markus    150:        unsigned char buf[4];
                    151:        buffer_get(buffer, (char *) buf, 4);
                    152:        return GET_32BIT(buf);
1.1       deraadt   153: }
                    154:
1.6       deraadt   155: /*
                    156:  * Stores an integer in the buffer in 4 bytes, msb first.
                    157:  */
1.11      markus    158: void
1.5       markus    159: buffer_put_int(Buffer *buffer, unsigned int value)
1.1       deraadt   160: {
1.5       markus    161:        char buf[4];
                    162:        PUT_32BIT(buf, value);
                    163:        buffer_append(buffer, buf, 4);
1.1       deraadt   164: }
                    165:
1.6       deraadt   166: /*
                    167:  * Returns an arbitrary binary string from the buffer.  The string cannot
                    168:  * be longer than 256k.  The returned value points to memory allocated
                    169:  * with xmalloc; it is the responsibility of the calling function to free
                    170:  * the data.  If length_ptr is non-NULL, the length of the returned data
                    171:  * will be stored there.  A null character will be automatically appended
                    172:  * to the returned string, and is not counted in length.
                    173:  */
1.5       markus    174: char *
                    175: buffer_get_string(Buffer *buffer, unsigned int *length_ptr)
1.1       deraadt   176: {
1.5       markus    177:        unsigned int len;
                    178:        char *value;
                    179:        /* Get the length. */
                    180:        len = buffer_get_int(buffer);
                    181:        if (len > 256 * 1024)
                    182:                fatal("Received packet with bad string length %d", len);
                    183:        /* Allocate space for the string.  Add one byte for a null character. */
                    184:        value = xmalloc(len + 1);
                    185:        /* Get the string. */
                    186:        buffer_get(buffer, value, len);
                    187:        /* Append a null character to make processing easier. */
                    188:        value[len] = 0;
                    189:        /* Optionally return the length of the string. */
                    190:        if (length_ptr)
                    191:                *length_ptr = len;
                    192:        return value;
1.1       deraadt   193: }
                    194:
1.6       deraadt   195: /*
                    196:  * Stores and arbitrary binary string in the buffer.
                    197:  */
1.11      markus    198: void
1.5       markus    199: buffer_put_string(Buffer *buffer, const void *buf, unsigned int len)
1.1       deraadt   200: {
1.5       markus    201:        buffer_put_int(buffer, len);
                    202:        buffer_append(buffer, buf, len);
1.9       markus    203: }
1.11      markus    204: void
1.9       markus    205: buffer_put_cstring(Buffer *buffer, const char *s)
                    206: {
                    207:        buffer_put_string(buffer, s, strlen(s));
1.1       deraadt   208: }
                    209:
1.6       deraadt   210: /*
                    211:  * Returns a character from the buffer (0 - 255).
                    212:  */
1.11      markus    213: int
1.5       markus    214: buffer_get_char(Buffer *buffer)
1.1       deraadt   215: {
1.5       markus    216:        char ch;
                    217:        buffer_get(buffer, &ch, 1);
                    218:        return (unsigned char) ch;
1.1       deraadt   219: }
                    220:
1.6       deraadt   221: /*
                    222:  * Stores a character in the buffer.
                    223:  */
1.11      markus    224: void
1.5       markus    225: buffer_put_char(Buffer *buffer, int value)
1.1       deraadt   226: {
1.5       markus    227:        char ch = value;
                    228:        buffer_append(buffer, &ch, 1);
1.1       deraadt   229: }