srp.c

iscsi源代码 UNH的progect 有initiator端和target端的源码

	     (char *) my_kmalloc(len + 1, "SRP user name")) == NULL)
		return 0;
	strcpy(p_context->name, p_username);

	return 1;
}

int
SRP_SetSecret(char *p_secret, struct SRP_Context * p_context)
{
	int len;

	if ((p_secret == NULL) || (p_context == NULL))
		return 0;

	my_kfree((void **) &p_context->secret, "SRP secret");

	len = strlen(p_secret);
	if ((p_context->secret =
	     (char *) my_kmalloc(len + 1, "SRP secret")) == NULL)
		return 0;
	strcpy(p_context->secret, p_secret);

	return 1;
}

int
SRP_SetNumberFormat(int p_format, struct SRP_Context * p_context)
{
	if ((p_context->format == HEX_FORMAT) ||
	    (p_context->format == BASE64_FORMAT)) {
		p_context->format = p_format;
		return 1;
	} else
		return 0;
}

int
SRP_SetSRPGroup(char *p_group, struct SRP_Context * p_context)
{
	char *N;
	char *G;
	int N_len;
	int G_len;
	int i;
	int group;

	group = -1;

	if ((p_group == NULL) || (p_context == NULL))
		return 0;

	for (i = SRP_768; i <= SRP_2048; i++) {
		if (!strcmp(SRP_GROUP_NAMES[i], p_group)) {
			group = i;
			break;
		}
	}

	switch (group) {
	case SRP_768:
		N = SRP_768_N;
		G = SRP_768_G;
		N_len = SRP_768_N_LEN;
		G_len = SRP_768_G_LEN;
		break;
	case SRP_1024:
		N = SRP_1024_N;
		G = SRP_1024_G;
		N_len = SRP_1024_N_LEN;
		G_len = SRP_1024_G_LEN;
		break;
	case SRP_1280:
		N = SRP_1280_N;
		G = SRP_1280_G;
		N_len = SRP_1280_N_LEN;
		G_len = SRP_1280_G_LEN;
		break;
	case SRP_1536:
		N = SRP_1536_N;
		G = SRP_1536_G;
		N_len = SRP_1536_N_LEN;
		G_len = SRP_1536_G_LEN;
		break;
	case SRP_2048:
		N = SRP_2048_N;
		G = SRP_2048_G;
		N_len = SRP_2048_N_LEN;
		G_len = SRP_2048_G_LEN;
		break;
	default:
		return 0;
	}

	my_kfree((void **) &p_context->N.data, "SRP N");
	if ((p_context->N.data = (char *)
	     my_kmalloc(N_len, "SRP N")) == NULL)
		return 0;
	memcpy(p_context->N.data, N, N_len);
	p_context->N.length = N_len;

	my_kfree((void **) &p_context->generator.data, "SRP generator");
	if ((p_context->generator.data = (char *)
	     my_kmalloc(G_len, "SRP generator")) == NULL)
		return 0;
	memcpy(p_context->generator.data, G, G_len);
	p_context->generator.length = G_len;

	p_context->group = group;
	return 1;
}

// target functions

int
SRP_Target_SetA(char *p_A, int max_length, struct SRP_Context * p_context)
{
	int len;

	if ((p_A == NULL) || (p_context == NULL))
		return 0;

	len = StringToIntegerLength(p_A);
	if (len > max_length) {
		TRACE_ERROR("SRP_A binary length is %d, limit is %d\n", len,
			    max_length);
		return 0;
	}

	if ((p_context->A.data =
	     (char *) my_kmalloc(len, "context's A")) == NULL)
		return 0;

	StringToInteger(p_A, p_context->A.data);
	p_context->A.length = len;
	return 1;
}

int
SRP_Target_SetM(char *p_M, int max_length, struct SRP_Context * p_context)
{
	int len;
	char *temp;
	int ret;

	if ((p_M == NULL) || (p_context == NULL))
		return 0;

	if (!CalculateTargetS(p_context))
		return 0;

	if (!CalculateM(p_context))
		return 0;

	len = StringToIntegerLength(p_M);
	if (len > max_length) {
		TRACE_ERROR("SRP_M binary length is %d, limit is %d\n", len,
			    max_length);
		return 0;
	}

	if ((temp = (char *) my_kmalloc(len, "temp M")) == NULL)
		return 0;

	StringToInteger(p_M, temp);
	ret = IntegerCompare(p_context->M.data, p_context->M.length, temp, len);
	my_kfree((void **) &temp, "temp M");
	return ret;
}

char *
SRP_Target_GetGroupList(struct SRP_Context * p_context)
{
	char *data;

	if ((data = my_kmalloc(44, "SRP group list")) == NULL)
		return NULL;

	sprintf(data, "%s,%s,%s,%s,%s",
		SRP_GROUP_NAMES[SRP_768],
		SRP_GROUP_NAMES[SRP_1024],
		SRP_GROUP_NAMES[SRP_1280],
		SRP_GROUP_NAMES[SRP_1536], SRP_GROUP_NAMES[SRP_2048]);
	return data;
}

/*	returns index number of group_name, -1 if not found */
int
SRP_GetGroupIndex(char *group_name, struct SRP_Context * p_context)
{
	int i;

	for (i = 0; i < SRP_N_GROUPS; i++) {
		if (!strcmp(SRP_GROUP_NAMES[i], group_name))
			return i;
	}
	return -1;
}

char *
SRP_Target_GetSalt(struct SRP_Context * p_context)
{
	int len;
	char *temp;

	if (p_context == NULL)
		return NULL;

	if ((p_context->salt.data =
	     (char *) my_kmalloc(SRP_SALT_LENGTH, "salt")) == NULL)
		return NULL;

	RandomNumberGenerate(p_context->salt.data, SRP_SALT_LENGTH);
	p_context->salt.length = SRP_SALT_LENGTH;

	len = IntegerToStringLength(p_context->salt.length, p_context->format);
	if ((temp = (char *) my_kmalloc(len, "SRP_s")) == NULL)
		return NULL;
	IntegerToString(p_context->salt.data, p_context->salt.length, temp,
			p_context->format);
	return temp;
}

char *
SRP_Target_GetB(struct SRP_Context * p_context)
{
	int len;
	char *data;

	if (p_context == NULL)
		return NULL;

	if (!CalculateB(p_context))
		return NULL;

	if (p_context->B.length == 0)
		return NULL;

	len = IntegerToStringLength(p_context->B.length, p_context->format);
	if ((data = (char *) my_kmalloc(len, "SRP_B")) == NULL)
		return NULL;
	IntegerToString(p_context->B.data,
			p_context->B.length, data, p_context->format);
	return data;
}

char *
SRP_Target_GetHM(struct SRP_Context * p_context)
{
	int len;
	char *data;
	if (p_context == NULL)
		return NULL;

	if (!CalculateHM(p_context))
		return NULL;

	if (p_context->HM.length == 0)
		return NULL;

	len = IntegerToStringLength(p_context->HM.length, p_context->format);
	if ((data = (char *) my_kmalloc(len, "SRP_HM")) == NULL)
		return NULL;
	IntegerToString(p_context->HM.data,
			p_context->HM.length, data, p_context->format);
	return data;
}

// initiator functions

int
SRP_Initiator_SetSalt(char *p_salt, int max_length, struct SRP_Context * p_context)
{
	int len;

	if ((p_salt == NULL) && (p_context == NULL))
		return 0;

	len = StringToIntegerLength(p_salt);
	if (len > max_length) {
		TRACE_ERROR("SRP_s binary length is %d, limit is %d\n", len,
			    max_length);
		return 0;
	}

	if ((p_context->salt.data = (char *) my_kmalloc(len, "salt")) == NULL)
		return 0;

	StringToInteger(p_salt, p_context->salt.data);
	p_context->salt.length = len;
	return 1;
}

int
SRP_Initiator_SetB(char *p_B, int max_length, struct SRP_Context * p_context)
{
	int len;

	if ((p_B == NULL) || (p_context == NULL))
		return 0;

	len = StringToIntegerLength(p_B);
	if (len > max_length) {
		TRACE_ERROR("SRP_B binary length is %d, limit is %d\n", len,
			    max_length);
		return 0;
	}

	if ((p_context->B.data = (char *) my_kmalloc(len, "B")) == NULL)
		return 0;
	StringToInteger(p_B, p_context->B.data);
	p_context->B.length = len;
	return 1;
}

int
SRP_Initiator_SetHM(char *p_HM, int max_length, struct SRP_Context * p_context)
{
	int len;
	char *temp;
	int ret;

	if ((p_HM == NULL) || (p_context == NULL))
		return 0;

	if (!CalculateHM(p_context))
		return 0;

	len = StringToIntegerLength(p_HM);
	if (len > max_length) {
		TRACE_ERROR("SRP_HM binary length is %d, limit is %d\n", len,
			    max_length);
		return 0;
	}

	if ((temp = (char *) my_kmalloc(len, "temp HM")) == NULL)
		return 0;

	StringToInteger(p_HM, temp);
	ret = IntegerCompare(p_context->HM.data,
			     p_context->HM.length, temp, len);
	my_kfree((void **) &temp, "temp HM");
	return ret;
}

char *
SRP_Initiator_GetUsername(struct SRP_Context * p_context)
{
	int len;
	char *data;

	if ((!p_context) || (!p_context->name))
		return NULL;
	len = strlen(p_context->name);
	if ((data = (char *) my_kmalloc(len + 1, "SRP_U")) == NULL)
		return NULL;
	strcpy(data, p_context->name);
	return data;
}

char *
SRP_Initiator_GetGroup(char *p_groups[], struct SRP_Context * p_context)
{
	int i;
	char *data;

	if ((!p_groups) || (!p_context))
		return NULL;

	if ((p_context->group < 0) && (p_context->group >= SRP_N_GROUPS))
		return NULL;

	/* check to make sure SRP_1536 was offered */
	i = 0;
	while (p_groups[i] != NULL) {
		if (!strcmp(p_groups[i], SRP_GROUP_NAMES[SRP_1536]))
			break;;
		i++;
	}
	if (p_groups[i] == NULL) {
		TRACE(TRACE_ISCSI,
		      "Warning, %s not offered in SRP_GROUP list\n",
		      SRP_GROUP_NAMES[SRP_1536]);
	}

	/* now go back and find the prefered choice */
	i = 0;
	while (p_groups[i] != NULL) {
		if (!strcmp(p_groups[i], SRP_GROUP_NAMES[p_context->group]))
			break;;
		i++;
	}
	if (p_groups[i] != NULL) {
		if ((data = (char *) my_kmalloc(strlen(p_groups[i]) + 1,
						"selected SRP_GROUP")) == NULL)
			return NULL;
		strcpy(data, p_groups[i]);
		return data;
	} else
		return NULL;
}

char *
SRP_Initiator_GetA(struct SRP_Context * p_context)
{
	int len;
	char *data;

	if (p_context == NULL)
		return NULL;

	if (!CalculateA(p_context))
		return NULL;

	if (p_context->A.length == 0)
		return NULL;

	len = IntegerToStringLength(p_context->A.length, p_context->format);
	if ((data = (char *) my_kmalloc(len, "SRP_A")) == NULL)
		return NULL;

	IntegerToString(p_context->A.data,
			p_context->A.length, data, p_context->format);
	return data;
}

char *
SRP_Initiator_GetM(struct SRP_Context * p_context)
{
	int len;
	char *data;

	if (p_context == NULL)
		return NULL;

	if (!CalculateX(p_context))
		return 0;

	if (!CalculateInitiatorS(p_context))
		return 0;

	if (!CalculateM(p_context))
		return NULL;

	if (p_context->M.length == 0)
		return NULL;

	len = IntegerToStringLength(p_context->M.length, p_context->format);
	if ((data = (char *) my_kmalloc(len, "SRP_M")) == NULL)
		return NULL;

	IntegerToString(p_context->M.data,
			p_context->M.length, data, p_context->format);
	return data;
}