srp.c

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

		return 0;

	p_context->K.length = 40;
	if ((p_context->K.data = (char *) my_kmalloc(40, "K")) == NULL)
		return 0;

	SHA1_Interleave(p_context->S.data,
			p_context->S.length, p_context->K.data);
	return 1;
}

int
CalculateM(struct SRP_Context * p_context)
{
	char *total;
	unsigned long long lentemp;
	unsigned int len;
	int ret;

	ret = 0;
	if ((p_context == NULL) ||
	    (p_context->B.length == 0) || (p_context->A.length == 0)) {
		printk("error : not enough data given\n");
		return 0;
	}

	if (!CalculateK(p_context))
		return 0;

	total = NULL;

	len = p_context->A.length + p_context->B.length + p_context->K.length;

	if ((total = (char *) my_kmalloc(len, "total")) == NULL)
		goto out;

	memcpy(total, p_context->A.data, p_context->A.length);
	memcpy(total + p_context->A.length, p_context->B.data,
	       p_context->B.length);
	memcpy(total + p_context->A.length + p_context->B.length,
	       p_context->K.data, p_context->K.length);
	if ((p_context->M.data = (char *) my_kmalloc(20, "M")) == NULL)
		goto out;

	p_context->M.length = 20;
	lentemp = len * 8;
	SHA1_ProcessMessage(total, (int) (lentemp >> 32),
			    (int) lentemp, p_context->M.data);
	ret = 1;
      out:
	my_kfree((void **) &total, "total");
	return ret;
}

int
CalculateB(struct SRP_Context * p_context)
{
	struct bigint_t N;
	struct bigint_t b;
	struct bigint_t generator;
	struct bigint_t B;
	struct bigint_t temp;
	struct bigint_t verifier;
	int ret;

	ret = 0;

	if ((p_context == NULL) ||
	    (p_context->N.length == 0) || (p_context->generator.length == 0))
		return 0;

	if (!CalculateX(p_context))
		return 0;

	if (!CalculateVerifier(p_context))
		return 0;

	p_context->b.length = SRP_B_LENGTH;
	if ((p_context->b.data =
	     (char *) my_kmalloc(SRP_B_LENGTH, "b")) == NULL)
		goto out;

	RandomNumberGenerate(p_context->b.data, SRP_B_LENGTH);

	if (!bigint_init_bin(&b, p_context->b.data, p_context->b.length))
		goto out;

	if (!bigint_init_bin(&N, p_context->N.data, p_context->N.length))
		goto out;

	if (!bigint_init_bin(&generator, p_context->generator.data,
			     p_context->generator.length))
		goto out;

	if (!bigint_init_bin(&verifier, p_context->verifier.data,
			     p_context->verifier.length))
		goto out;

	if (!bigint_init(&temp, 0))
		goto out;

	if (!bigint_init(&B, 0))
		goto out;

	if (!bigint_mod_exp_mont(&temp, &generator, &b, &N))
		goto out;

	if (!bigint_mod_add(&B, &temp, &verifier, &N))
		goto out;

	p_context->B.length = bigint_binlen(&B);

	my_kfree((void **) &p_context->B.data, "B");

	if ((p_context->B.data = (char *) my_kmalloc(p_context->B.length,
						     "B")) == NULL)
		goto out;

	if (!bigint_tobin(&B, p_context->B.data))
		goto out;

	ret = 1;

      out:
	bigint_clean(&N);
	bigint_clean(&generator);
	bigint_clean(&temp);
	bigint_clean(&B);
	bigint_clean(&verifier);
	bigint_clean(&b);

	return ret;
}

int
CalculateTargetS(struct SRP_Context * p_context)
{
	unsigned long long len;
	struct bigint_t N;
	struct bigint_t b;
	struct bigint_t generator;
	struct bigint_t A;
	struct bigint_t u;
	struct bigint_t verifier;
	struct bigint_t temp1;
	struct bigint_t temp2;
	struct bigint_t temp3;
	char digest[20];
	int ret;

	ret = 0;
	if ((p_context == NULL) ||
	    (p_context->N.length == 0) ||
	    (p_context->b.length == 0) ||
	    (p_context->A.length == 0) ||
	    (p_context->B.length == 0) ||
	    (p_context->verifier.length == 0) ||
	    (p_context->generator.length == 0))
		return 0;

	len = p_context->B.length * 8;
	SHA1_ProcessMessage(p_context->B.data,
			    (int) (len >> 32), (int) len, digest);
	p_context->u.length = 4;

	if ((p_context->u.data = (char *) my_kmalloc(4, "u")) == NULL)
		goto out;
	memcpy(p_context->u.data, digest, 4);

	if (!bigint_init_bin(&N, p_context->N.data, p_context->N.length))
		goto out;

	if (!bigint_init_bin(&b, p_context->b.data, p_context->b.length))
		goto out;

	if (!bigint_init_bin(&generator, p_context->generator.data,
			     p_context->generator.length))
		goto out;

	if (!bigint_init_bin(&A, p_context->A.data, p_context->A.length))
		goto out;

	if (!bigint_init_bin(&u, p_context->u.data, p_context->u.length))
		goto out;

	if (!bigint_init_bin(&verifier, p_context->verifier.data,
			     p_context->verifier.length))
		goto out;

	if (!bigint_init(&temp1, 0))
		goto out;

	if (!bigint_init(&temp2, 0))
		goto out;

	if (!bigint_init(&temp3, 0))
		goto out;

	if (!bigint_mod_exp_mont(&temp1, &verifier, &u, &N))
		goto out;

	if (!bigint_mul(&temp2, &A, &temp1))
		goto out;

	if (!bigint_mod_exp_mont(&temp3, &temp2, &b, &N))
		goto out;

	p_context->S.length = bigint_binlen(&temp3);

	my_kfree((void **) &p_context->S.data, "S");

	if ((p_context->S.data = (char *) my_kmalloc(p_context->S.length,
						     "S")) == NULL)
		goto out;

	if (!bigint_tobin(&temp3, p_context->S.data))
		goto out;

	ret = 1;
      out:
	bigint_clean(&N);
	bigint_clean(&generator);
	bigint_clean(&A);
	bigint_clean(&u);
	bigint_clean(&verifier);
	bigint_clean(&b);
	bigint_clean(&temp1);
	bigint_clean(&temp2);
	bigint_clean(&temp3);

	return ret;
}

int
CalculateHM(struct SRP_Context * p_context)
{
	int len;
	unsigned long long lentemp;
	char *temp;

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

	len = p_context->A.length + p_context->M.length + p_context->K.length;
	if ((temp = (char *) my_kmalloc(len, "temp")) == NULL)
		return 0;

	memcpy(temp, p_context->A.data, p_context->A.length);
	memcpy(temp + p_context->A.length,
	       p_context->M.data, p_context->M.length);
	memcpy(temp + p_context->A.length
	       + p_context->M.length, p_context->K.data, p_context->K.length);
	if ((p_context->HM.data = (char *) my_kmalloc(20, "HM")) == NULL) {
		my_kfree((void **) &temp, "temp");
		return 0;
	}

	p_context->HM.length = 20;
	lentemp = len * 8;
	SHA1_ProcessMessage(temp, (int) (lentemp >> 32),
			    (int) lentemp, p_context->HM.data);
	my_kfree((void **) &temp, "temp");
	return 1;
}

// common functions

struct 
SRP_Context *
SRP_InitializeContext(void)
{
	struct SRP_Context *context;

	if ((context =
	     (struct SRP_Context *) my_kmalloc(sizeof (struct SRP_Context),
					"SRP Context")) == NULL)
		return NULL;
	ClearSRPContext(context);
	return context;
}

void
SRP_FinalizeContext(struct SRP_Context * p_context)
{
	if (!p_context)
		return;

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

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

	my_kfree((void **) &p_context->salt.data, "context's salt");

	my_kfree((void **) &p_context->verifier.data, "context's verifier");

	my_kfree((void **) &p_context->S.data, "S");

	my_kfree((void **) &p_context->a.data, "context's a");

	my_kfree((void **) &p_context->A.data, "context's A");

	my_kfree((void **) &p_context->b.data, "context's b");

	my_kfree((void **) &p_context->B.data, "context's B");

	my_kfree((void **) &p_context->X.data, "context's X");

	my_kfree((void **) &p_context->u.data, "context's u");

	my_kfree((void **) &p_context->K.data, "context's K");

	my_kfree((void **) &p_context->M.data, "context's M");

	my_kfree((void **) &p_context->HM.data, "context's HM");

	my_kfree((void **) &p_context->N.data, "SRP N");

	my_kfree((void **) &p_context->generator.data, "SRP generator");

	my_kfree((void **) &p_context, "context");
}

struct SRP_Context *
SRP_CloneContext(struct SRP_Context * p_context)
{
	struct SRP_Context *context;

	if (!p_context)
		return NULL;

	if ((context = SRP_InitializeContext()) == NULL)
		return NULL;

	context->format = p_context->format;
	context->group = p_context->group;

	if (p_context->name) {
		if ((context->name = my_kmalloc(strlen(p_context->name) + 1,
						"SRP user name")) == NULL)
			goto out;
		strcpy(context->name, p_context->name);
	}

	if (p_context->secret) {
		if ((context->secret = my_kmalloc(strlen(p_context->secret + 1),
						  "SRP secret")) == NULL)
			goto out;
		strcpy(context->secret, p_context->secret);
	}

	if (!CloneDataUnit(&context->salt, &p_context->salt))
		goto out;

	if (!CloneDataUnit(&context->verifier, &p_context->verifier))
		goto out;

	if (!CloneDataUnit(&context->S, &p_context->S))
		goto out;

	if (!CloneDataUnit(&context->a, &p_context->a))
		goto out;

	if (!CloneDataUnit(&context->A, &p_context->A))
		goto out;

	if (!CloneDataUnit(&context->b, &p_context->b))
		goto out;

	if (!CloneDataUnit(&context->B, &p_context->B))
		goto out;

	if (!CloneDataUnit(&context->X, &p_context->X))
		goto out;

	if (!CloneDataUnit(&context->u, &p_context->u))
		goto out;

	if (!CloneDataUnit(&context->K, &p_context->K))
		goto out;

	if (!CloneDataUnit(&context->M, &p_context->M))
		goto out;

	if (!CloneDataUnit(&context->HM, &p_context->HM))
		goto out;

	if (!CloneDataUnit(&context->N, &p_context->N))
		goto out;

	if (!CloneDataUnit(&context->generator, &p_context->generator))
		goto out;

	return context;
      out:
	SRP_FinalizeContext(context);
	return NULL;
}

void
SRP_PrintContext(struct SRP_Context * p_context)
{
	printk
	    ("\n******************************************************************\n");
	printk("format\t: ");
	if (p_context->format == HEX_FORMAT)
		printk("HEX\n");
	else if (p_context->format == BASE64_FORMAT)
		printk("BASE64\n");
	else
		printk("Unknown\n");
	printk("name\t: %s\n", p_context->name);
	printk("secret\t: %s\n", p_context->secret);
	printk("salt\t\t: ");
	PrintDataUnit(&p_context->salt);
	printk("verifier\t: ");
	PrintDataUnit(&p_context->verifier);
	printk("S\t\t: ");
	PrintDataUnit(&p_context->S);
	printk("a\t\t: ");
	PrintDataUnit(&p_context->a);
	printk("A\t\t: ");
	PrintDataUnit(&p_context->A);
	printk("b\t\t: ");
	PrintDataUnit(&p_context->b);
	printk("B\t\t: ");
	PrintDataUnit(&p_context->B);
	printk("X\t\t: ");
	PrintDataUnit(&p_context->X);
	printk("u\t\t: ");
	PrintDataUnit(&p_context->u);
	printk("K\t\t: ");
	PrintDataUnit(&p_context->K);
	printk("M\t\t: ");
	PrintDataUnit(&p_context->M);
	printk("HM\t\t: ");
	PrintDataUnit(&p_context->HM);
	printk("N\t\t: ");
	PrintDataUnit(&p_context->N);
	printk("Generator\t: ");
	PrintDataUnit(&p_context->generator);
	printk
	    ("******************************************************************\n");
}

int
SRP_SetName(char *p_username, struct SRP_Context * p_context)
{
	int len;

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

	my_kfree((void **) &p_context->name, "SRP user name");
	len = strlen(p_username);
	if ((p_context->name =