ref: a8d00e5d56b261376410c3c87c46327362763bd8
dir: /sys/src/cmd/ssh/msg.c/
#include "ssh.h" static ulong sum32(ulong, void*, int); char *msgnames[] = { /* 0 */ "SSH_MSG_NONE", "SSH_MSG_DISCONNECT", "SSH_SMSG_PUBLIC_KEY", "SSH_CMSG_SESSION_KEY", "SSH_CMSG_USER", "SSH_CMSG_AUTH_RHOSTS", "SSH_CMSG_AUTH_RSA", "SSH_SMSG_AUTH_RSA_CHALLENGE", "SSH_CMSG_AUTH_RSA_RESPONSE", "SSH_CMSG_AUTH_PASSWORD", /* 10 */ "SSH_CMSG_REQUEST_PTY", "SSH_CMSG_WINDOW_SIZE", "SSH_CMSG_EXEC_SHELL", "SSH_CMSG_EXEC_CMD", "SSH_SMSG_SUCCESS", "SSH_SMSG_FAILURE", "SSH_CMSG_STDIN_DATA", "SSH_SMSG_STDOUT_DATA", "SSH_SMSG_STDERR_DATA", "SSH_CMSG_EOF", /* 20 */ "SSH_SMSG_EXITSTATUS", "SSH_MSG_CHANNEL_OPEN_CONFIRMATION", "SSH_MSG_CHANNEL_OPEN_FAILURE", "SSH_MSG_CHANNEL_DATA", "SSH_MSG_CHANNEL_INPUT_EOF", "SSH_MSG_CHANNEL_OUTPUT_CLOSED", "SSH_MSG_UNIX_DOMAIN_X11_FORWARDING (obsolete)", "SSH_SMSG_X11_OPEN", "SSH_CMSG_PORT_FORWARD_REQUEST", "SSH_MSG_PORT_OPEN", /* 30 */ "SSH_CMSG_AGENT_REQUEST_FORWARDING", "SSH_SMSG_AGENT_OPEN", "SSH_MSG_IGNORE", "SSH_CMSG_EXIT_CONFIRMATION", "SSH_CMSG_X11_REQUEST_FORWARDING", "SSH_CMSG_AUTH_RHOSTS_RSA", "SSH_MSG_DEBUG", "SSH_CMSG_REQUEST_COMPRESSION", "SSH_CMSG_MAX_PACKET_SIZE", "SSH_CMSG_AUTH_TIS", /* 40 */ "SSH_SMSG_AUTH_TIS_CHALLENGE", "SSH_CMSG_AUTH_TIS_RESPONSE", "SSH_CMSG_AUTH_KERBEROS", "SSH_SMSG_AUTH_KERBEROS_RESPONSE", "SSH_CMSG_HAVE_KERBEROS_TGT" }; void badmsg(Msg *m, int want) { char *s, buf[20+ERRMAX]; if(m==nil){ snprint(buf, sizeof buf, "<early eof: %r>"); s = buf; }else{ snprint(buf, sizeof buf, "<unknown type %d>", m->type); s = buf; if(0 <= m->type && m->type < nelem(msgnames)) s = msgnames[m->type]; } if(want) error("got %s message expecting %s", s, msgnames[want]); error("got unexpected %s message", s); } Msg* allocmsg(Conn *c, int type, int len) { uchar *p; Msg *m; if(len > 256*1024) abort(); m = (Msg*)emalloc(sizeof(Msg)+4+8+1+len+4); setmalloctag(m, getcallerpc(&c)); p = (uchar*)&m[1]; m->c = c; m->bp = p; m->ep = p+len; m->wp = p; m->type = type; return m; } void unrecvmsg(Conn *c, Msg *m) { debug(DBG_PROTO, "unreceived %s len %zd\n", msgnames[m->type], m->ep - m->rp); free(c->unget); c->unget = m; } static Msg* recvmsg0(Conn *c) { int pad; uchar *p, buf[4]; ulong crc, crc0, len; Msg *m; if(c->unget){ m = c->unget; c->unget = nil; return m; } if(readn(c->fd[0], buf, 4) != 4){ werrstr("short net read: %r"); return nil; } len = LONG(buf); if(len > 256*1024){ werrstr("packet size far too big: %.8lux", len); return nil; } pad = 8 - len%8; m = (Msg*)emalloc(sizeof(Msg)+pad+len); setmalloctag(m, getcallerpc(&c)); m->c = c; m->bp = (uchar*)&m[1]; m->ep = m->bp + pad+len-4; /* -4: don't include crc */ m->rp = m->bp; if(readn(c->fd[0], m->bp, pad+len) != pad+len){ werrstr("short net read: %r"); free(m); return nil; } if(c->cipher) c->cipher->decrypt(c->cstate, m->bp, len+pad); crc = sum32(0, m->bp, pad+len-4); p = m->bp + pad+len-4; crc0 = LONG(p); if(crc != crc0){ werrstr("bad crc %#lux != %#lux (packet length %lud)", crc, crc0, len); free(m); return nil; } m->rp += pad; m->type = *m->rp++; return m; } Msg* recvmsg(Conn *c, int type) { Msg *m; while((m = recvmsg0(c)) != nil){ debug(DBG_PROTO, "received %s len %zd\n", msgnames[m->type], m->ep - m->rp); if(m->type != SSH_MSG_DEBUG && m->type != SSH_MSG_IGNORE) break; if(m->type == SSH_MSG_DEBUG) debug(DBG_PROTO, "remote DEBUG: %s\n", getstring(m)); free(m); } if(type == 0){ /* no checking */ }else if(type == -1){ /* must not be nil */ if(m == nil) error(Ehangup); }else{ /* must be given type */ if(m==nil || m->type!=type) badmsg(m, type); } setmalloctag(m, getcallerpc(&c)); return m; } int sendmsg(Msg *m) { int i, pad; uchar *p; ulong datalen, len, crc; Conn *c; datalen = m->wp - m->bp; len = datalen + 5; pad = 8 - len%8; debug(DBG_PROTO, "sending %s len %lud\n", msgnames[m->type], datalen); p = m->bp; memmove(m->bp+4+pad+1, m->bp, datalen); /* slide data to correct position */ PLONG(p, len); p += 4; if(m->c->cstate){ for(i=0; i<pad; i++) *p++ = fastrand(); }else{ memset(p, 0, pad); p += pad; } *p++ = m->type; /* data already in position */ p += datalen; crc = sum32(0, m->bp+4, pad+1+datalen); PLONG(p, crc); p += 4; c = m->c; qlock(c); if(c->cstate) c->cipher->encrypt(c->cstate, m->bp+4, len+pad); if(write(c->fd[1], m->bp, p - m->bp) != p-m->bp){ qunlock(c); free(m); return -1; } qunlock(c); free(m); return 0; } uchar getbyte(Msg *m) { if(m->rp >= m->ep) error(Edecode); return *m->rp++; } ushort getshort(Msg *m) { ushort x; if(m->rp+2 > m->ep) error(Edecode); x = SHORT(m->rp); m->rp += 2; return x; } ulong getlong(Msg *m) { ulong x; if(m->rp+4 > m->ep) error(Edecode); x = LONG(m->rp); m->rp += 4; return x; } char* getstring(Msg *m) { char *p; ulong len; /* overwrites length to make room for NUL */ len = getlong(m); if(m->rp+len > m->ep) error(Edecode); p = (char*)m->rp-1; memmove(p, m->rp, len); p[len] = '\0'; return p; } void* getbytes(Msg *m, int n) { uchar *p; if(m->rp+n > m->ep) error(Edecode); p = m->rp; m->rp += n; return p; } mpint* getmpint(Msg *m) { int n; n = (getshort(m)+7)/8; /* getshort returns # bits */ return betomp(getbytes(m, n), n, nil); } RSApub* getRSApub(Msg *m) { RSApub *key; getlong(m); key = rsapuballoc(); if(key == nil) error(Ememory); key->ek = getmpint(m); key->n = getmpint(m); setmalloctag(key, getcallerpc(&m)); return key; } void putbyte(Msg *m, uchar x) { if(m->wp >= m->ep) error(Eencode); *m->wp++ = x; } void putshort(Msg *m, ushort x) { if(m->wp+2 > m->ep) error(Eencode); PSHORT(m->wp, x); m->wp += 2; } void putlong(Msg *m, ulong x) { if(m->wp+4 > m->ep) error(Eencode); PLONG(m->wp, x); m->wp += 4; } void putstring(Msg *m, char *s) { int len; len = strlen(s); putlong(m, len); putbytes(m, s, len); } void putbytes(Msg *m, void *a, long n) { if(m->wp+n > m->ep) error(Eencode); memmove(m->wp, a, n); m->wp += n; } void putmpint(Msg *m, mpint *b) { int bits, n; bits = mpsignif(b); putshort(m, bits); n = (bits+7)/8; if(m->wp+n > m->ep) error(Eencode); mptobe(b, m->wp, n, nil); m->wp += n; } void putRSApub(Msg *m, RSApub *key) { putlong(m, mpsignif(key->n)); putmpint(m, key->ek); putmpint(m, key->n); } static ulong crctab[256]; static void initsum32(void) { ulong crc, poly; int i, j; poly = 0xEDB88320; for(i = 0; i < 256; i++){ crc = i; for(j = 0; j < 8; j++){ if(crc & 1) crc = (crc >> 1) ^ poly; else crc >>= 1; } crctab[i] = crc; } } static ulong sum32(ulong lcrc, void *buf, int n) { static int first=1; uchar *s = buf; ulong crc = lcrc; if(first){ first=0; initsum32(); } while(n-- > 0) crc = crctab[(crc^*s++)&0xff] ^ (crc>>8); return crc; } mpint* rsapad(mpint *b, int n) { int i, pad, nbuf; uchar buf[2560]; mpint *c; if(n > sizeof buf) error("buffer too small in rsapad"); nbuf = (mpsignif(b)+7)/8; pad = n - nbuf; assert(pad >= 3); mptobe(b, buf, nbuf, nil); memmove(buf+pad, buf, nbuf); buf[0] = 0; buf[1] = 2; for(i=2; i<pad-1; i++) buf[i]=1+fastrand()%255; buf[pad-1] = 0; c = betomp(buf, n, nil); memset(buf, 0, sizeof buf); return c; } mpint* rsaunpad(mpint *b) { int i, n; uchar buf[2560]; n = (mpsignif(b)+7)/8; if(n > sizeof buf) error("buffer too small in rsaunpad"); mptobe(b, buf, n, nil); /* the initial zero has been eaten by the betomp -> mptobe sequence */ if(buf[0] != 2) error("bad data in rsaunpad"); for(i=1; i<n; i++) if(buf[i]==0) break; return betomp(buf+i, n-i, nil); } void mptoberjust(mpint *b, uchar *buf, int len) { int n; n = mptobe(b, buf, len, nil); assert(n >= 0); if(n < len){ len -= n; memmove(buf+len, buf, n); memset(buf, 0, len); } } mpint* rsaencryptbuf(RSApub *key, uchar *buf, int nbuf) { int n; mpint *a, *b, *c; n = (mpsignif(key->n)+7)/8; a = betomp(buf, nbuf, nil); b = rsapad(a, n); mpfree(a); c = rsaencrypt(key, b, nil); mpfree(b); return c; }