xref: /freebsd-9.3-release/sbin/iscontrol/login.c

/*-
 * Copyright (c) 2005-2010 Daniel Braniss <danny@cs.huji.ac.il>
 * 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.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``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 OR CONTRIBUTORS 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.
 *
 */
/*
 | $Id: login.c,v 1.4 2007/04/27 07:40:40 danny Exp danny $
 */

#include <sys/cdefs.h>
__FBSDID("$FreeBSD$");

#include <sys/param.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <sys/sysctl.h>

#include <netinet/in.h>
#include <netinet/tcp.h>
#include <arpa/inet.h>
#include <sys/ioctl.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#include <dev/iscsi/initiator/iscsi.h>
#include "iscontrol.h"

static char *status_class1[] = {
     "Initiator error",
     "Authentication failure",
     "Authorization failure",
     "Not found",
     "Target removed",
     "Unsupported version",
     "Too many connections",
     "Missing parameter",
     "Can't include in session",
     "Session type not suported",
     "Session does not exist",
     "Invalid during login",
};
#define CLASS1_ERRS ((sizeof status_class1) / sizeof(char *))

static char *status_class3[] = {
     "Target error",
     "Service unavailable",
     "Out of resources"
};
#define CLASS3_ERRS ((sizeof status_class3) / sizeof(char *))

static char *
selectFrom(char *str, token_t *list)
{
     char	*sep, *sp;
     token_t	*lp;
     int	n;

     sp = str;
     do {
	  sep = strchr(sp, ',');
	  if(sep != NULL)
	       n = sep - sp;
	  else
	       n = strlen(sp);

	  for(lp = list; lp->name != NULL; lp++) {
	       if(strncasecmp(lp->name, sp, n) == 0)
		    return strdup(lp->name);
	  }
	  sp = sep + 1;
     } while(sep != NULL);

     return NULL;
}

static char *
getkeyval(char *key, pdu_t *pp)
{
    char	*ptr;
    int	klen, len, n;

    debug_called(3);

    len = pp->ds_len;
    ptr = (char *)pp->ds_addr;
    klen = strlen(key);
    while(len > klen) {
	 if(strncmp(key, ptr, klen) == 0)
	      return ptr+klen;
	 n = strlen(ptr) + 1;
	 len -= n;
	 ptr += n;
    }
    return 0;
}

static int
handleTgtResp(isess_t *sess, pdu_t *pp)
{
     isc_opt_t	*op = sess->op;
     char	*np, *rp, *d1, *d2;
     int	res, l1, l2;

     res = -1;
     if(((np = getkeyval("CHAP_N=", pp)) == NULL) ||
	((rp = getkeyval("CHAP_R=", pp)) == NULL))
	  goto out;
     if(strcmp(np, op->tgtChapName? op->tgtChapName: op->initiatorName) != 0) {
	  fprintf(stderr, "%s does not match\n", np);
	  goto out;
     }
     l1 = str2bin(op->tgtChapDigest, &d1);
     l2 = str2bin(rp, &d2);

     debug(3, "l1=%d '%s' l2=%d '%s'", l1, op->tgtChapDigest, l2, rp);
     if(l1 == l2 && memcmp(d1, d2, l1) == 0)
	res = 0;
     if(l1)
	  free(d1);
     if(l2)
	  free(d2);
 out:
     free(op->tgtChapDigest);
     op->tgtChapDigest = NULL;

     debug(3, "res=%d", res);

     return res;
}

static void
processParams(isess_t *sess, pdu_t *pp)
{
     isc_opt_t		*op = sess->op;
     int		len, klen, n;
     char		*eq, *ptr;

     debug_called(3);

     len = pp->ds_len;
     ptr = (char *)pp->ds_addr;
     while(len > 0) {
	  if(vflag > 1)
	       printf("got: len=%d %s\n", len, ptr);
	  klen = 0;
	  if((eq = strchr(ptr, '=')) != NULL)
	       klen = eq - ptr;
	  if(klen > 0) {
	       if(strncmp(ptr, "TargetAddress", klen) == 0) {
		    char	*p, *q, *ta = NULL;

		    // TargetAddress=domainname[:port][,portal-group-tag]
		    // XXX: if(op->targetAddress) free(op->targetAddress);
		    q = op->targetAddress = strdup(eq+1);
		    if(*q == '[') {
			 // bracketed IPv6
			 if((q = strchr(q, ']')) != NULL) {
			      *q++ = '\0';
			      ta = op->targetAddress;
			      op->targetAddress = strdup(ta+1);
			 } else
			      q = op->targetAddress;
		    }
		    if((p = strchr(q, ',')) != NULL) {
			 *p++ = 0;
			 op->targetPortalGroupTag = atoi(p);
		    }
		    if((p = strchr(q, ':')) != NULL) {
			 *p++ = 0;
			 op->port = atoi(p);
		    }
		    if(ta)
			 free(ta);
	       } else if(strncmp(ptr, "MaxRecvDataSegmentLength", klen) == 0) {
		    // danny's RFC
		    op->maxXmitDataSegmentLength = strtol(eq+1, (char **)NULL, 0);
	       } else  if(strncmp(ptr, "TargetPortalGroupTag", klen) == 0) {
		    op->targetPortalGroupTag = strtol(eq+1, (char **)NULL, 0);
	       } else if(strncmp(ptr, "HeaderDigest", klen) == 0) {
		    op->headerDigest = selectFrom(eq+1, DigestMethods);
	       } else if(strncmp(ptr, "DataDigest", klen) == 0) {
		    op->dataDigest = selectFrom(eq+1, DigestMethods);
	       } else if(strncmp(ptr, "MaxOutstandingR2T", klen) == 0)
		    op->maxOutstandingR2T = strtol(eq+1, (char **)NULL, 0);
#if 0
	       else
	       for(kp = keyMap; kp->name; kp++) {
		    if(strncmp(ptr, kp->name, kp->len) == 0 && ptr[kp->len] == '=')
			 mp->func(sess, ptr+kp->len+1, GET);
	       }
#endif
	  }
	  n = strlen(ptr) + 1;
	  len -= n;
	  ptr += n;
     }

}

static int
handleLoginResp(isess_t *sess, pdu_t *pp)
{
     login_rsp_t *lp = (login_rsp_t *)pp;
     uint	st_class, status = ntohs(lp->status);

     debug_called(3);
     debug(4, "Tbit=%d csg=%d nsg=%d status=%x", lp->T, lp->CSG, lp->NSG, status);

     st_class  = status >> 8;
     if(status) {
	  uint	st_detail = status & 0xff;

	  switch(st_class) {
	  case 1: // Redirect
	       switch(st_detail) {
		    // the ITN (iSCSI target Name) requests a:
	       case 1: // temporary address change
	       case 2: // permanent address change
		    status = 0;
	       }
	       break;

	  case 2: // Initiator Error
	       if(st_detail < CLASS1_ERRS)
		    printf("0x%04x: %s\n", status, status_class1[st_detail]);
	       break;

	  case 3:
	       if(st_detail < CLASS3_ERRS)
		    printf("0x%04x: %s\n", status, status_class3[st_detail]);
	       break;
	  }
     }

     if(status == 0) {
	  processParams(sess, pp);
	  setOptions(sess, 0); // XXX: just in case ...

	  if(lp->T) {
	       isc_opt_t	*op = sess->op;

	       if(sess->csg == SN_PHASE && (op->tgtChapDigest != NULL))
		    if(handleTgtResp(sess, pp) != 0)
			 return 1; // XXX: Authentication failure ...
	       sess->csg = lp->NSG;
	       if(sess->csg == FF_PHASE) {
		    // XXX: will need this when implementing reconnect.
		    sess->tsih = lp->tsih;
		    debug(2, "TSIH=%x", sess->tsih);
	       }
	  }
     }

     return st_class;
}

static int
handleChap(isess_t *sess, pdu_t *pp)
{
     pdu_t		spp;
     login_req_t	*lp;
     isc_opt_t		*op = sess->op;
     char		*ap, *ip, *cp, *digest; // MD5 is 128bits, SHA1 160bits

     debug_called(3);

     bzero(&spp, sizeof(pdu_t));
     lp = (login_req_t *)&spp.ipdu.bhs;
     lp->cmd = ISCSI_LOGIN_CMD | 0x40; // login request + Inmediate
     memcpy(lp->isid, sess->isid, 6);
     lp->tsih = sess->tsih;    // MUST be zero the first time!
     lp->CID = htons(1);
     lp->CSG = SN_PHASE;       // Security Negotiation
     lp->NSG = LON_PHASE;
     lp->T = 1;

     if(((ap = getkeyval("CHAP_A=", pp)) == NULL) ||
	((ip = getkeyval("CHAP_I=", pp)) == NULL) ||
	((cp = getkeyval("CHAP_C=", pp)) == NULL))
	  return -1;

     if((digest = chapDigest(ap, (char)strtol(ip, (char **)NULL, 0), cp, op->chapSecret)) == NULL)
	  return -1;

     addText(&spp, "CHAP_N=%s", op->chapIName? op->chapIName: op->initiatorName);
     addText(&spp, "CHAP_R=%s", digest);
     free(digest);

     if(op->tgtChapSecret != NULL) {
	  op->tgtChapID = (random() >> 24) % 255; // should be random enough ...
	  addText(&spp, "CHAP_I=%d", op->tgtChapID);
	  cp = genChapChallenge(cp, op->tgtChallengeLen? op->tgtChallengeLen: 8);
	  addText(&spp, "CHAP_C=%s", cp);
	  op->tgtChapDigest = chapDigest(ap, op->tgtChapID, cp, op->tgtChapSecret);
     }

     return sendPDU(sess, &spp, handleLoginResp);
}

static int
authenticate(isess_t *sess)
{
     pdu_t		spp;
     login_req_t	*lp;
     isc_opt_t	*op = sess->op;

     bzero(&spp, sizeof(pdu_t));
     lp = (login_req_t *)&spp.ipdu.bhs;
     lp->cmd = ISCSI_LOGIN_CMD | 0x40; // login request + Inmediate
     memcpy(lp->isid, sess->isid, 6);
     lp->tsih = sess->tsih;	// MUST be zero the first time!
     lp->CID = htons(1);
     lp->CSG = SN_PHASE;	// Security Negotiation
     lp->NSG = SN_PHASE;
     lp->T = 0;

     switch((authm_t)lookup(AuthMethods, op->authMethod)) {
     case NONE:
	  return 0;

     case KRB5:
     case SPKM1:
     case SPKM2:
     case SRP:
	  return 2;

     case CHAP:
	  if(op->chapDigest == 0)
	       addText(&spp, "CHAP_A=5");
	  else
	  if(strcmp(op->chapDigest, "MD5") == 0)
	       addText(&spp, "CHAP_A=5");
	  else
	  if(strcmp(op->chapDigest, "SHA1") == 0)
	       addText(&spp, "CHAP_A=7");
	  else
	       addText(&spp, "CHAP_A=5,7");
	  return sendPDU(sess, &spp, handleChap);
     }
     return 1;
}

int
loginPhase(isess_t *sess)
{
     pdu_t		spp, *sp = &spp;
     isc_opt_t  	*op = sess->op;
     login_req_t	*lp;
     int		status = 1;

     debug_called(3);

     bzero(sp, sizeof(pdu_t));
     lp = (login_req_t *)&spp.ipdu.bhs;
     lp->cmd = ISCSI_LOGIN_CMD | 0x40; // login request + Inmediate
     memcpy(lp->isid, sess->isid, 6);
     lp->tsih = sess->tsih;	// MUST be zero the first time!
     lp->CID = htons(1);	// sess->cid?

     if((lp->CSG = sess->csg) == LON_PHASE)
	  lp->NSG = FF_PHASE;	// lets try and go full feature ...
     else
	  lp->NSG = LON_PHASE;
     lp->T = 1;			// transit to next login stage

     if(sess->flags & SESS_INITIALLOGIN1) {
	  sess->flags &= ~SESS_INITIALLOGIN1;

	  addText(sp, "SessionType=%s", op->sessionType);
	  addText(sp, "InitiatorName=%s", op->initiatorName);
	  if(strcmp(op->sessionType, "Discovery") != 0) {
	       addText(sp, "TargetName=%s", op->targetName);
	  }
     }
     switch(sess->csg) {
     case SN_PHASE:	// Security Negotiation
	  addText(sp, "AuthMethod=%s", op->authMethod);
	  break;

     case LON_PHASE:	// Login Operational Negotiation
	  if((sess->flags & SESS_NEGODONE) == 0) {
	       sess->flags |= SESS_NEGODONE;
	       addText(sp, "MaxBurstLength=%d", op->maxBurstLength);
	       addText(sp, "HeaderDigest=%s", op->headerDigest);
	       addText(sp, "DataDigest=%s", op->dataDigest);
	       addText(sp, "MaxRecvDataSegmentLength=%d", op->maxRecvDataSegmentLength);
	       addText(sp, "ErrorRecoveryLevel=%d", op->errorRecoveryLevel);
	       addText(sp, "DefaultTime2Wait=%d", op->defaultTime2Wait);
	       addText(sp, "DefaultTime2Retain=%d", op->defaultTime2Retain);
	       addText(sp, "DataPDUInOrder=%s", op->dataPDUInOrder? "Yes": "No");
	       addText(sp, "DataSequenceInOrder=%s", op->dataSequenceInOrder? "Yes": "No");
	       addText(sp, "MaxOutstandingR2T=%d", op->maxOutstandingR2T);

	       if(strcmp(op->sessionType, "Discovery") != 0) {
		    addText(sp, "MaxConnections=%d", op->maxConnections);
		    addText(sp, "FirstBurstLength=%d", op->firstBurstLength);
		    addText(sp, "InitialR2T=%s", op->initialR2T? "Yes": "No");
		    addText(sp, "ImmediateData=%s", op->immediateData? "Yes": "No");
	       }
	  }

	  break;
     }

     status = sendPDU(sess, &spp, handleLoginResp);

     switch(status) {
     case 0: // all is ok ...
	  if(sess->csg == SN_PHASE)
	       /*
		| if we are still here, then we need
		| to exchange some secrets ...
	        */
	       status = authenticate(sess);
     }

     return status;
}