packetstorm sync

1 files changed, 677 insertions, 0 deletions

diff --git a/other/guess-who/ssh.cc b/other/guess-who/ssh.cc
new file mode 100644
index 0000000..11055da
--- /dev/null
+++ b/other/guess-who/ssh.cc
@@ -0,0 +1,677 @@
+/*
+ * Copyright (C) 2002,2003 Sebastian Krahmer.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 3. All advertising materials mentioning features or use of this software
+ *    must display the following acknowledgement:
+ *      This product includes software developed by Sebastian Krahmer.
+ * 4. The name Sebastian Krahmer may not be used to endorse or promote
+ *    products derived from this software without specific prior written
+ *    permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ */
+#include <stdio.h>
+#include <sys/types.h>
+#include <errno.h>
+#include <string.h>
+#include <unistd.h>
+#include <assert.h>
+#include <netinet/in.h>
+#include <sys/stat.h>
+
+extern "C" {
+#include <openssl/dh.h>
+#include <openssl/bn.h>
+#include <openssl/hmac.h>
+#include <openssl/evp.h>
+#include <openssl/rsa.h>
+};
+
+#include <pthread.h>
+
+#include "ssh.h"
+#include "misc.h"
+#include "base64.h"
+
+using namespace std;
+
+DH *dh_new_group_asc(const char *gen, const char *modulus)
+{
+        DH *dh;
+
+        dh = DH_new();
+        if (dh == NULL)
+                fprintf(stderr, "DH_new returned NULL");
+
+        if (BN_hex2bn(&dh->p, modulus) == 0)
+                fprintf(stderr, "BN_hex2bn (p) returned 0");
+        if (BN_hex2bn(&dh->g, gen) == 0)
+                fprintf(stderr, "BN_hex2bn (g) returned 0");
+
+        return (dh);
+}
+
+/*
+ * This just returns the group, we still need to generate the exchange
+ * value.
+ */
+
+DH *dh_new_group(BIGNUM *gen, BIGNUM *modulus)
+{
+        DH *dh;
+
+        dh = DH_new();
+        if (dh == NULL)
+                fprintf(stderr, "DH_new returned NULL");
+        dh->p = modulus;
+        dh->g = gen;
+
+        return (dh);
+}
+
+DH *dh_new_group1(void)
+{
+        static char *gen = "2", *group1 =
+            "FFFFFFFF" "FFFFFFFF" "C90FDAA2" "2168C234" "C4C6628B" "80DC1CD1"
+            "29024E08" "8A67CC74" "020BBEA6" "3B139B22" "514A0879" "8E3404DD"
+            "EF9519B3" "CD3A431B" "302B0A6D" "F25F1437" "4FE1356D" "6D51C245"
+            "E485B576" "625E7EC6" "F44C42E9" "A637ED6B" "0BFF5CB6" "F406B7ED"
+            "EE386BFB" "5A899FA5" "AE9F2411" "7C4B1FE6" "49286651" "ECE65381"
+            "FFFFFFFF" "FFFFFFFF";
+
+        return (dh_new_group_asc(gen, group1));
+}
+
+
+int SSH2::packet_write(const void *buf, size_t buflen)
+{
+        unsigned char packet[32768], pad[16],
+                      padding, mac[20];
+        unsigned char *ptr = packet, *enc_packet = NULL;
+        unsigned short paylen = 0;
+        size_t mac_len = sizeof(mac);
+        int r;
+
+        assert(buflen < 32000);
+
+        padding = 8 - ((buflen+1+4) % 8);
+        if (padding < 4)
+                padding += 8;
+        *(u_int32_t*)ptr = htonl(buflen+1+padding);     // paylen
+        ptr += sizeof(u_int32_t);
+        paylen += sizeof(u_int32_t);
+        *ptr = padding;
+        ++ptr;
+        ++paylen;
+        memcpy(ptr, buf, buflen);
+        ptr += buflen;
+        paylen += buflen;
+        memcpy(ptr, pad, padding);
+        paylen += padding;
+        ptr += paylen;
+
+        if (use_crypto) {
+                HMAC_CTX c;
+                u_int32_t s = htonl(seq);
+                HMAC_Init(&c, s_mac, sizeof(s_mac), EVP_sha1());
+                HMAC_Update(&c, (unsigned char*)&s, sizeof(s));
+                HMAC_Update(&c, packet, paylen);
+                HMAC_Final(&c, mac, &mac_len);
+        }
+
+        ++seq;  // one more packet written
+        if (debug > 0)
+                fprintf(stderr, "sending %d byte (%d padding) ", paylen, padding);
+
+        if (use_crypto) {
+                if (debug > 0)
+                        fprintf(stderr, "crypted\n");
+                enc_packet = new unsigned char[paylen+mac_len];
+                des_ede3_cbc_encrypt(packet, enc_packet, paylen,
+                             s_key1, s_key2, s_key3,
+                             &s_iv, DES_ENCRYPT);
+                memcpy(enc_packet+paylen, mac, mac_len);
+                r = writen(peer, enc_packet, paylen+mac_len);
+                delete [] enc_packet;
+        } else {
+                if (debug > 0)
+                        fprintf(stderr, "plain\n");
+                r = writen(peer, packet, paylen);
+                if (r <= 0) {
+                        error = "SSH2::packet_write::write(): ";
+                        error += strerror(errno);
+                }
+        }
+        return r;
+}
+
+
+// return the number bytes read or -1 on error
+// puts length of payload in n. packet may be trunced if
+// plen < 32768
+int SSH2::packet_read(unsigned char *plain_buf, size_t pblen, size_t *n)
+{
+        unsigned char buf[32768], *ptr = NULL;
+        unsigned char dec_packet[32768];
+
+        int r;
+
+        if ((r = read(peer, buf, sizeof(buf))) <= 0) {
+                error = "SSH2::packet_read::read() ";
+                error += strerror(errno);
+                return -1;
+        }
+
+        // maybe TODO: check MAC
+        if (use_crypto) {
+                if (r - 20 < 0) {
+                        error = "SSH2::read_packet: Invalid packet ";
+                        return -1;
+                }
+                des_ede3_cbc_encrypt(buf, dec_packet, r-20,
+                             r_key1, r_key2, r_key3,
+                             &r_iv, DES_DECRYPT);
+                ptr = dec_packet;
+        } else
+                ptr = buf;
+
+        *n = ntohl(*(u_int32_t*)ptr);
+        ptr += sizeof(u_int32_t);
+        *n -= *ptr;     // minus paylen
+        --*n;           // minus one
+        if (*n > (size_t)r) {
+                error = "SSH2::packet_read: bad packet size";
+                return -1;
+        }
+        
+        ++ptr;
+        memcpy(plain_buf, ptr, pblen < *n ? pblen : *n);
+        return r;
+}
+
+
+int SSH2::banner_exchange()
+{
+        int r;
+        char buf[1024], banner[] = "SSH-2.0-guess-who\r\n";
+
+        // Add V_C to hash input
+        to_hash_len = strlen(banner)-2 + sizeof(u_int32_t);
+        to_hash = (unsigned char*)realloc(to_hash, to_hash_len);
+        *(u_int32_t*)to_hash = htonl(strlen(banner)-2);
+        memcpy(&to_hash[sizeof(u_int32_t)], banner, strlen(banner)-2);
+
+        memset(buf, 0, sizeof(buf));
+        if ((r = read(peer, buf, sizeof(buf))) <= 0) {
+                error = "SSH2::banner_exchange::read() ";
+                error += strerror(errno);
+                return -1;
+        }
+        char *crlf;
+        if ((crlf = strchr(buf, '\n')) != NULL)
+                *crlf = 0;
+        if ((crlf = strchr(buf, '\r')) != NULL)
+                *crlf = 0;
+        snprintf(d_banner, sizeof(buf), "%s", buf);
+
+        // Add V_S to hash input
+        to_hash = (unsigned char*)realloc(to_hash, to_hash_len+strlen(buf) + sizeof(u_int32_t));
+        *(u_int32_t*)&to_hash[to_hash_len] = htonl(strlen(buf));
+        to_hash_len += sizeof(u_int32_t);
+        memcpy(&to_hash[to_hash_len], buf, strlen(buf));
+        to_hash_len += strlen(buf);
+
+        if ((r = writen(peer, banner, strlen(banner))) <= 0) {
+                error = "SSH2::banner_exchange::writen() ";
+                error = strerror(errno);
+        }
+
+        return 0;
+}
+
+
+int SSH2::kex_init()
+{
+        char my_kex_msg[] = 
+                "\x14"  // SSH_MSG_KEXINIT
+                "\x00\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0a\x0b\x0c\x0d\x0e\x0f"
+                "\x00\x00\x00\x1a" "diffie-hellman-group1-sha1" // kex algo
+                "\x00\x00\x00\x07" "ssh-dss"    // server hostkey algo
+                "\x00\x00\x00\x08" "3des-cbc"   // client to server enc algo
+                "\x00\x00\x00\x08" "3des-cbc"   // server to client enc algo
+                "\x00\x00\x00\x09" "hmac-sha1"  // client to server MAC algo
+                "\x00\x00\x00\x09" "hmac-sha1"  // server to client MAC algo
+                "\x00\x00\x00\x04" "none"       // client to server comp algo
+                "\x00\x00\x00\x04" "none"       // server to client comp algo
+                "\x00\x00\x00\x00"              // client to server language
+                "\x00\x00\x00\x00"              // server to client language
+                "\x00"
+                "\x00\x00\x00\x00";
+        unsigned char buf[1024], *ptr;
+        int r;
+        size_t n;
+
+        // Add I_C to hash input
+        to_hash = (unsigned char*)realloc(to_hash, to_hash_len+sizeof(my_kex_msg)-1+sizeof(u_int32_t));
+        *(u_int32_t*)&to_hash[to_hash_len] = htonl(sizeof(my_kex_msg)-1);
+        to_hash_len += sizeof(u_int32_t);
+        memcpy(&to_hash[to_hash_len], my_kex_msg, sizeof(my_kex_msg)-1);
+        to_hash_len += sizeof(my_kex_msg)-1;
+
+        r = packet_write(my_kex_msg, sizeof(my_kex_msg)-1);
+        if (r < 0) {
+                error = "SSH2::kex_init::packet_write() ";
+                error = strerror(errno);
+                return -1;
+        }
+        if (packet_read(buf, sizeof(buf), &n) <= 0)
+                return -1;
+        ptr = buf;
+        if (*ptr != SSH_MSG_KEXINIT) {
+                error = "SSH2::kex_init: packet type != SSH_MSG_KEXINIT";
+                return -1;
+        }
+
+        // Add I_S to hash input
+        to_hash = (unsigned char*)realloc(to_hash, to_hash_len+n+sizeof(u_int32_t));
+        *(u_int32_t*)&to_hash[to_hash_len] = htonl(n);
+        to_hash_len += sizeof(u_int32_t);
+        memcpy(&to_hash[to_hash_len], ptr, n);
+        to_hash_len += n;
+
+        return 0;
+}
+
+
+int SSH2::hash_helper(const char *letter, unsigned char d1[20],
+        unsigned char d2[20], bool expand)
+{
+        EVP_MD_CTX md;
+        EVP_DigestInit(&md, EVP_sha1());
+
+        // shared_secret as mpint
+        unsigned char *secret = new unsigned char[shared_secret_len+1+4];
+        int h = *shared_secret & 0x80 ? 1 : 0;
+        *(u_int32_t*)secret = htonl(shared_secret_len+h);
+        secret[sizeof(u_int32_t)] = 0;
+        memcpy(&secret[sizeof(u_int32_t)+h], shared_secret, shared_secret_len);
+
+        EVP_DigestUpdate(&md, secret, shared_secret_len+h+4);
+        EVP_DigestUpdate(&md, session_id, sizeof(session_id));
+        EVP_DigestUpdate(&md, (unsigned char*)letter, 1);
+        EVP_DigestUpdate(&md, session_id, sizeof(session_id));
+        EVP_DigestFinal(&md, d1, NULL);
+
+        // Our expansion gives 40bytes, enough for 3DES keys and IV's
+        if (expand) {
+                EVP_DigestInit(&md, EVP_sha1());
+                EVP_DigestUpdate(&md, secret, shared_secret_len+h+4);
+                EVP_DigestUpdate(&md, session_id, sizeof(session_id));
+                EVP_DigestUpdate(&md, d1, 20); // sizeof(d1) == 4 !!!
+                EVP_DigestFinal(&md, d2, NULL);
+        }
+
+        delete [] secret;
+        return 0;
+}
+
+
+int SSH2::derive_keys()
+{
+        // First, compute HASH == session_id
+        EVP_MD_CTX md;
+        EVP_DigestInit(&md, EVP_sha1());
+        EVP_DigestUpdate(&md, to_hash, to_hash_len);
+        EVP_DigestFinal(&md, session_id, NULL);
+
+        if (debug > 1)
+                buffer_dump("session_id", session_id, sizeof(session_id));
+
+        unsigned char d1[20], d2[20];
+        hash_helper("A", d1, d2, 0); memcpy(s_iv, d1, 8);
+        hash_helper("B", d1, d2, 0); memcpy(r_iv, d1, 8);
+
+        // Now for the encryption keys: we need to expand to 24 byte
+        hash_helper("C", d1, d2, 1);
+        des_set_key((const_des_cblock*)d1, s_key1);
+        des_set_key((const_des_cblock*)(d1+8), s_key2);
+
+        // last 4 byte of d1 and first 4 byte of d2 build 3rd key. ufff.
+        unsigned char dummy[8];
+        memcpy(dummy, d1+16, 4); memcpy(dummy+4, d2, 4);
+        des_set_key((const_des_cblock*)dummy, s_key3);
+//      buffer_dump("C", d1, 20);
+//      buffer_dump("C", d2, 4);
+
+
+        hash_helper("D", d1, d2, 1);
+//      buffer_dump("D", d1, 20);
+//      buffer_dump("D", d2, 4);
+
+
+        des_set_key((const_des_cblock*)d1, r_key1);
+        des_set_key((const_des_cblock*)(d1+8), r_key2);
+        memcpy(dummy, d1+16, 4); memcpy(dummy+4, d2, 4);
+        des_set_key((const_des_cblock*)dummy, r_key3);
+
+        // MAC keys have same length as their hashoutput of used
+        // hashing function
+        hash_helper("E", s_mac, d2, 0);
+        hash_helper("F", r_mac, d2, 0);
+        return 0;
+}
+
+
+
+int SSH2::dh_exchange()
+{
+        DH *e = dh_new_group1();
+
+        // generate x as in secsh-draft
+        e->priv_key = BN_new();
+        if (BN_rand(e->priv_key, 1024, 0, 0) == 0) {
+                error = "SSH2::dh_exchange::BN_rand() returned 0";
+                return -1;
+        }
+        // compute e = g^x mod p
+        if (DH_generate_key(e) == 0) {
+                error = "SSH2::dh_exchange::DH_generate_key() returned 0";
+                return -1;
+        }
+        unsigned char *e_bin = new unsigned char[BN_num_bytes(e->pub_key)+1+1+4];
+        unsigned char *e_tmp = new unsigned char[BN_num_bytes(e->pub_key)];
+
+        assert(e_bin && e_tmp);
+
+        BN_bn2bin(e->pub_key, e_tmp);
+        int h = *e_tmp & 0x80 ? 1 : 0;
+
+        // send e as mpint across network
+        e_bin[0] = SSH_MSG_KEXDH_INIT;
+
+        // Somehow OpenSSH looks whether e is signed and adds 0x00 in front
+        // if so (length incremented by one). 'h' is true when highbit is set
+        // Thats why we mess with e_tmp: We need to add 0x00 in some cases and
+        // stretch the length by one. Same for shared_secret few lines later.
+        e_bin[5] = 0;
+        *(u_int32_t*)&e_bin[1] = htonl(BN_num_bytes(e->pub_key)+h);
+        memcpy(&e_bin[5+h], e_tmp, BN_num_bytes(e->pub_key));
+        packet_write(e_bin, BN_num_bytes(e->pub_key)+h+1+4);
+
+        delete [] e_tmp;
+
+
+        size_t n;
+        unsigned char server_blob[32768], *ptr = server_blob;
+        if (packet_read(server_blob, sizeof(server_blob), &n) <= 0)
+                return -1;
+
+        if (*ptr != SSH_MSG_KEXDH_REPLY) {
+                error = "SSH2::dh_exchange: type != SSH_MSG_KEXDH_REPLY";
+                return -1;
+        }
+        ++ptr;
+        
+        // hostkey is a string
+        size_t hostkey_len = ntohl(*(u_int32_t*)ptr);
+
+
+        // Add K_S to hash input, its already in string format
+        to_hash = (unsigned char*)realloc(to_hash, to_hash_len+hostkey_len+sizeof(u_int32_t));
+        memcpy(&to_hash[to_hash_len], ptr, hostkey_len+sizeof(u_int32_t));
+        to_hash_len += hostkey_len + sizeof(u_int32_t);
+        
+        ptr += sizeof(u_int32_t);
+        ptr += hostkey_len;
+
+        // Add e to hash input, already in mpint format at &e_bin[1]
+        to_hash = (unsigned char*)realloc(to_hash, to_hash_len+BN_num_bytes(e->pub_key)+h+4);
+        memcpy(&to_hash[to_hash_len], e_bin+1, BN_num_bytes(e->pub_key)+h+4);
+        to_hash_len += BN_num_bytes(e->pub_key)+h+4;
+
+        delete [] e_bin;
+
+        if (debug > 0)
+                fprintf(stderr, "hostkey_len=%d\n", hostkey_len);
+
+        // get f. f is mpint (which is same as string :)
+        size_t f_len = ntohl(*(u_int32_t*)ptr);
+
+
+        // Add f to hash input, already in mpint format
+        to_hash = (unsigned char*)realloc(to_hash, to_hash_len+f_len+sizeof(u_int32_t));
+        memcpy(&to_hash[to_hash_len], ptr, f_len+sizeof(u_int32_t));
+        to_hash_len += f_len+sizeof(u_int32_t);
+
+        // go to f
+        ptr += sizeof(u_int32_t);
+
+        BIGNUM *f = BN_new();
+        BN_bin2bn(ptr, f_len, f);
+
+        shared_secret = new unsigned char[DH_size(e)];
+        shared_secret_len = DH_compute_key(shared_secret, f, e);
+
+        // Add shared_secret to hash input
+        // Once again, add 0x00 of it is signed
+        h = *shared_secret & 0x80 ? 1 : 0;
+        to_hash = (unsigned char*)realloc(to_hash, to_hash_len+shared_secret_len+sizeof(u_int32_t)+h);
+        *(u_int32_t*)&to_hash[to_hash_len] = htonl(shared_secret_len+h);
+        to_hash_len += sizeof(u_int32_t);
+        to_hash[to_hash_len] = 0;
+        memcpy(&to_hash[to_hash_len+h], shared_secret, shared_secret_len);
+        to_hash_len += shared_secret_len+h;
+
+
+        if (debug > 1)
+                buffer_dump("shared_secret", shared_secret, shared_secret_len);
+//      buffer_dump("to_hash", to_hash, to_hash_len);
+
+        derive_keys();
+
+        return 0;
+}
+
+
+int SSH2::newkeys()
+{
+        char c = SSH_MSG_NEWKEYS;
+        int r = packet_write(&c, 1);
+        use_crypto = 1;
+        return r;
+}
+
+
+int SSH2::userauth_passwd(const char *user, const char *password)
+{
+        char preq[32768], *ptr = preq;
+        size_t preq_len = 0, l, n;
+        unsigned char reply[32768];
+
+        assert(strlen(user) + strlen(password) < 32000);
+
+
+        preq[0] = SSH_MSG_SERVICE_REQUEST;
+        ++ptr;
+        *(u_int32_t*)ptr = htonl(12);
+        ptr += sizeof(u_int32_t);
+        memcpy(ptr, "ssh-userauth", 12);
+        ptr += 12;
+        packet_write(preq, ptr-preq);
+        if (packet_read(reply, sizeof(reply), &n) < 0)
+                return -1;
+        if (reply[0] != SSH_MSG_SERVICE_ACCEPT) {
+                error = "SSH2::userauth_passwd: 'ssh-userauth' message not accepted";
+                sprintf(preq, "(%d)", reply[0]);
+                error += preq;
+                return -1;
+        }       
+        ptr = preq;
+        preq[0] = SSH_MSG_USERAUTH_REQUEST;
+        ++ptr;
+        ++preq_len;
+
+        *(u_int32_t*)ptr = htonl(strlen(user));
+        ptr += sizeof(u_int32_t);
+        preq_len += sizeof(u_int32_t);
+        memcpy(ptr, user, strlen(user));
+        ptr += strlen(user);
+        preq_len += strlen(user);
+
+        *(u_int32_t*)ptr = htonl((l = strlen("ssh-connection")));
+        ptr += sizeof(u_int32_t);
+        preq_len += sizeof(u_int32_t);
+        memcpy(ptr, "ssh-connection", l);
+        ptr += l;
+        preq_len += l;
+
+        *(u_int32_t*)ptr = htonl((l = strlen("password")));
+        ptr += sizeof(u_int32_t);
+        preq_len += sizeof(u_int32_t);
+        memcpy(ptr, "password", l);
+        ptr += l;
+        preq_len += l;
+
+        *ptr = 0;       // FALSE ;-)
+        ++ptr;
+        ++preq_len;
+
+        *(u_int32_t*)ptr = htonl((l = strlen(password)));
+        ptr += sizeof(u_int32_t);
+        preq_len += sizeof(u_int32_t);
+        memcpy(ptr, password, l);
+        ptr += l;
+        preq_len += l;
+
+        packet_write(preq, preq_len);
+
+        memset(reply, 0, sizeof(reply));
+        do {
+                if (packet_read(reply, sizeof(reply), &n) < 0)
+                        return -1;
+        } while (reply[0] != SSH_MSG_USERAUTH_FAILURE && 
+                 reply[0] != SSH_MSG_USERAUTH_SUCCESS);
+
+        return (reply[0] == SSH_MSG_USERAUTH_FAILURE);
+}
+
+/* Only checks whether pubkey is valid */
+int SSH2::userauth_pubkey(const char *user, const char *keyfile)
+{
+        struct stat st;
+        unsigned char reply[1024];
+        size_t n, l;
+        
+        FILE *f = fopen(keyfile, "r");
+        if (!f || stat(keyfile, &st) < 0) {
+                error = "SSH2::userauth_pubkey: ";
+                error += strerror(errno);
+                return -1;
+        }
+        char *buf = new char[st.st_size];
+        fgets(buf, st.st_size, f);
+
+        // jump over ssh-rsa
+        char *keyblob64 = strstr(buf, "ssh-rsa ");
+        if (!keyblob64) {
+                error = "SSH2::userauth_pubkey: Wrong format of keyfile";
+                return -1;
+        }
+        keyblob64 += 8;
+        char *tmp = strchr(keyblob64, ' ');
+        if (!keyblob64) {
+                error = "SSH2::userauth_pubkey: Wrong format of keyfile";
+                return -1;
+        }
+
+        // eliminate icke@dort
+        *tmp = 0;
+
+
+        // First, send SERVICE_REQUEST for userauth
+        char preq[128], *ptr = preq;
+        preq[0] = SSH_MSG_SERVICE_REQUEST;
+        ++ptr;
+        *(u_int32_t*)ptr = htonl(12);
+        ptr += sizeof(u_int32_t);
+        memcpy(ptr, "ssh-userauth", 12);
+        ptr += 12;
+        packet_write(preq, ptr-preq);
+        if (packet_read(reply, sizeof(reply), &n) < 0)
+                return -1;
+        if (reply[0] != SSH_MSG_SERVICE_ACCEPT) {
+                error = "SSH2::userauth_passwd: 'ssh-userauth' message not accepted";
+                return -1;
+        }       
+        
+
+        // now send USERAUTH_REQUEST for ssh-connection
+        // service
+        size_t len = 1 + strlen(user) + 4 + strlen("ssh-connection") + 4 +
+                     strlen("publickey") + 4 + 1 + strlen(keyblob64);
+        char *p = new char [len];
+        ptr = p;
+        *ptr = SSH_MSG_USERAUTH_REQUEST;
+        ++ptr;
+        *(u_int32_t*)ptr = htonl(l = strlen(user));
+        ptr += sizeof(u_int32_t);
+        memcpy(ptr, user, l);
+        ptr += l;
+
+        *(u_int32_t*)ptr = htonl(l = strlen("ssh-connection"));
+        ptr += sizeof(u_int32_t);
+        memcpy(ptr, "ssh-connection", l);
+        ptr += l;
+
+        *(u_int32_t*)ptr = htonl(l = strlen("publickey"));
+        ptr += sizeof(u_int32_t);
+        memcpy(ptr, "publickey", l);
+        ptr += l;
+
+        *ptr = 0;       // FALSE
+        ++ptr;
+
+        *(u_int32_t*)ptr = htonl(l = strlen("ssh-rsa"));
+        ptr += sizeof(u_int32_t);
+        memcpy(ptr, "ssh-rsa", l);
+        ptr += l;
+
+        unsigned char *keyblob = new unsigned char [strlen(keyblob64)];
+        l = b64_pton(keyblob64, keyblob, strlen(keyblob64));
+        *(u_int32_t*)ptr = htonl(l);
+        ptr += sizeof(u_int32_t);
+        memcpy(ptr, keyblob, l);
+        packet_write(p, ptr-p+l);
+
+        delete [] p;
+        delete [] buf;
+        delete [] keyblob;
+
+        do {
+                if (packet_read(reply, sizeof(reply), &n) < 0)
+                        return -1;
+        } while (reply[0] != SSH_MSG_USERAUTH_FAILURE && 
+                 reply[0] != SSH_MSG_USERAUTH_PK_OK);
+
+        return (reply[0] == SSH_MSG_USERAUTH_FAILURE);
+}
+