[u/mdw/putty] / sshdss.c

#include <stdio.h>
#include <stdlib.h>
#include <assert.h>

#include "ssh.h"

#define GET_32BIT(cp) \
    (((unsigned long)(unsigned char)(cp)[0] << 24) | \
    ((unsigned long)(unsigned char)(cp)[1] << 16) | \
    ((unsigned long)(unsigned char)(cp)[2] << 8) | \
    ((unsigned long)(unsigned char)(cp)[3]))

#define PUT_32BIT(cp, value) { \
    (cp)[0] = (unsigned char)((value) >> 24); \
    (cp)[1] = (unsigned char)((value) >> 16); \
    (cp)[2] = (unsigned char)((value) >> 8); \
    (cp)[3] = (unsigned char)(value); }

#if 0
#define DEBUG_DSS
#else
#define diagbn(x,y)
#endif

static void getstring(char **data, int *datalen, char **p, int *length)
{
    *p = NULL;
    if (*datalen < 4)
	return;
    *length = GET_32BIT(*data);
    *datalen -= 4;
    *data += 4;
    if (*datalen < *length)
	return;
    *p = *data;
    *data += *length;
    *datalen -= *length;
}
static Bignum getmp(char **data, int *datalen)
{
    char *p;
    int length;
    Bignum b;

    getstring(data, datalen, &p, &length);
    if (!p)
	return NULL;
    if (p[0] & 0x80)
	return NULL;		       /* negative mp */
    b = bignum_from_bytes(p, length);
    return b;
}

static Bignum get160(char **data, int *datalen)
{
    Bignum b;

    b = bignum_from_bytes(*data, 20);
    *data += 20;
    *datalen -= 20;

    return b;
}

struct dss_key {
    Bignum p, q, g, y;
};

static void *dss_newkey(char *data, int len)
{
    char *p;
    int slen;
    struct dss_key *dss;

    dss = smalloc(sizeof(struct dss_key));
    if (!dss)
	return NULL;
    getstring(&data, &len, &p, &slen);

#ifdef DEBUG_DSS
    {
	int i;
	printf("key:");
	for (i = 0; i < len; i++)
	    printf("  %02x", (unsigned char) (data[i]));
	printf("\n");
    }
#endif

    if (!p || memcmp(p, "ssh-dss", 7)) {
	sfree(dss);
	return NULL;
    }
    dss->p = getmp(&data, &len);
    dss->q = getmp(&data, &len);
    dss->g = getmp(&data, &len);
    dss->y = getmp(&data, &len);

    return dss;
}

static void dss_freekey(void *key)
{
    struct dss_key *dss = (struct dss_key *) key;
    freebn(dss->p);
    freebn(dss->q);
    freebn(dss->g);
    freebn(dss->y);
    sfree(dss);
}

static char *dss_fmtkey(void *key)
{
    struct dss_key *dss = (struct dss_key *) key;
    char *p;
    int len, i, pos, nibbles;
    static const char hex[] = "0123456789abcdef";
    if (!dss->p)
	return NULL;
    len = 8 + 4 + 1;		       /* 4 x "0x", punctuation, \0 */
    len += 4 * (bignum_bitcount(dss->p) + 15) / 16;
    len += 4 * (bignum_bitcount(dss->q) + 15) / 16;
    len += 4 * (bignum_bitcount(dss->g) + 15) / 16;
    len += 4 * (bignum_bitcount(dss->y) + 15) / 16;
    p = smalloc(len);
    if (!p)
	return NULL;

    pos = 0;
    pos += sprintf(p + pos, "0x");
    nibbles = (3 + bignum_bitcount(dss->p)) / 4;
    if (nibbles < 1)
	nibbles = 1;
    for (i = nibbles; i--;)
	p[pos++] =
	    hex[(bignum_byte(dss->p, i / 2) >> (4 * (i % 2))) & 0xF];
    pos += sprintf(p + pos, ",0x");
    nibbles = (3 + bignum_bitcount(dss->q)) / 4;
    if (nibbles < 1)
	nibbles = 1;
    for (i = nibbles; i--;)
	p[pos++] =
	    hex[(bignum_byte(dss->q, i / 2) >> (4 * (i % 2))) & 0xF];
    pos += sprintf(p + pos, ",0x");
    nibbles = (3 + bignum_bitcount(dss->g)) / 4;
    if (nibbles < 1)
	nibbles = 1;
    for (i = nibbles; i--;)
	p[pos++] =
	    hex[(bignum_byte(dss->g, i / 2) >> (4 * (i % 2))) & 0xF];
    pos += sprintf(p + pos, ",0x");
    nibbles = (3 + bignum_bitcount(dss->y)) / 4;
    if (nibbles < 1)
	nibbles = 1;
    for (i = nibbles; i--;)
	p[pos++] =
	    hex[(bignum_byte(dss->y, i / 2) >> (4 * (i % 2))) & 0xF];
    p[pos] = '\0';
    return p;
}

static char *dss_fingerprint(void *key)
{
    struct dss_key *dss = (struct dss_key *) key;
    struct MD5Context md5c;
    unsigned char digest[16], lenbuf[4];
    char buffer[16 * 3 + 40];
    char *ret;
    int numlen, i;

    MD5Init(&md5c);
    MD5Update(&md5c, "\0\0\0\7ssh-dss", 11);

#define ADD_BIGNUM(bignum) \
    numlen = (bignum_bitcount(bignum)+8)/8; \
    PUT_32BIT(lenbuf, numlen); MD5Update(&md5c, lenbuf, 4); \
    for (i = numlen; i-- ;) { \
        unsigned char c = bignum_byte(bignum, i); \
        MD5Update(&md5c, &c, 1); \
    }
    ADD_BIGNUM(dss->p);
    ADD_BIGNUM(dss->q);
    ADD_BIGNUM(dss->g);
    ADD_BIGNUM(dss->y);
#undef ADD_BIGNUM

    MD5Final(digest, &md5c);

    sprintf(buffer, "ssh-dss %d ", bignum_bitcount(dss->p));
    for (i = 0; i < 16; i++)
	sprintf(buffer + strlen(buffer), "%s%02x", i ? ":" : "",
		digest[i]);
    ret = smalloc(strlen(buffer) + 1);
    if (ret)
	strcpy(ret, buffer);
    return ret;
}

static int dss_verifysig(void *key, char *sig, int siglen,
			 char *data, int datalen)
{
    struct dss_key *dss = (struct dss_key *) key;
    char *p;
    int slen;
    char hash[20];
    Bignum r, s, w, gu1p, yu2p, gu1yu2p, u1, u2, sha, v;
    int ret;

    if (!dss->p)
	return 0;

#ifdef DEBUG_DSS
    {
	int i;
	printf("sig:");
	for (i = 0; i < siglen; i++)
	    printf("  %02x", (unsigned char) (sig[i]));
	printf("\n");
    }
#endif
    /*
     * Commercial SSH (2.0.13) and OpenSSH disagree over the format
     * of a DSA signature. OpenSSH is in line with the IETF drafts:
     * it uses a string "ssh-dss", followed by a 40-byte string
     * containing two 160-bit integers end-to-end. Commercial SSH
     * can't be bothered with the header bit, and considers a DSA
     * signature blob to be _just_ the 40-byte string containing
     * the two 160-bit integers. We tell them apart by measuring
     * the length: length 40 means the commercial-SSH bug, anything
     * else is assumed to be IETF-compliant.
     */
    if (siglen != 40) {		       /* bug not present; read admin fields */
	getstring(&sig, &siglen, &p, &slen);
	if (!p || slen != 7 || memcmp(p, "ssh-dss", 7)) {
	    return 0;
	}
	sig += 4, siglen -= 4;	       /* skip yet another length field */
    }
    diagbn("p=", dss->p);
    diagbn("q=", dss->q);
    diagbn("g=", dss->g);
    diagbn("y=", dss->y);
    r = get160(&sig, &siglen);
    diagbn("r=", r);
    s = get160(&sig, &siglen);
    diagbn("s=", s);
    if (!r || !s)
	return 0;

    /*
     * Step 1. w <- s^-1 mod q.
     */
    w = modinv(s, dss->q);
    diagbn("w=", w);

    /*
     * Step 2. u1 <- SHA(message) * w mod q.
     */
    SHA_Simple(data, datalen, hash);
    p = hash;
    slen = 20;
    sha = get160(&p, &slen);
    diagbn("sha=", sha);
    u1 = modmul(sha, w, dss->q);
    diagbn("u1=", u1);

    /*
     * Step 3. u2 <- r * w mod q.
     */
    u2 = modmul(r, w, dss->q);
    diagbn("u2=", u2);

    /*
     * Step 4. v <- (g^u1 * y^u2 mod p) mod q.
     */
    gu1p = modpow(dss->g, u1, dss->p);
    diagbn("gu1p=", gu1p);
    yu2p = modpow(dss->y, u2, dss->p);
    diagbn("yu2p=", yu2p);
    gu1yu2p = modmul(gu1p, yu2p, dss->p);
    diagbn("gu1yu2p=", gu1yu2p);
    v = modmul(gu1yu2p, One, dss->q);
    diagbn("gu1yu2q=v=", v);
    diagbn("r=", r);

    /*
     * Step 5. v should now be equal to r.
     */

    ret = !bignum_cmp(v, r);

    freebn(w);
    freebn(sha);
    freebn(gu1p);
    freebn(yu2p);
    freebn(gu1yu2p);
    freebn(v);
    freebn(r);
    freebn(s);

    return ret;
}

static unsigned char *dss_public_blob(void *key, int *len)
{
    struct dss_key *dss = (struct dss_key *) key;
    int plen, qlen, glen, ylen, bloblen;
    int i;
    unsigned char *blob, *p;

    plen = (bignum_bitcount(dss->p) + 8) / 8;
    qlen = (bignum_bitcount(dss->q) + 8) / 8;
    glen = (bignum_bitcount(dss->g) + 8) / 8;
    ylen = (bignum_bitcount(dss->y) + 8) / 8;

    /*
     * string "ssh-dss", mpint p, mpint q, mpint g, mpint y. Total
     * 27 + sum of lengths. (five length fields, 20+7=27).
     */
    bloblen = 27 + plen + qlen + glen + ylen;
    blob = smalloc(bloblen);
    p = blob;
    PUT_32BIT(p, 7);
    p += 4;
    memcpy(p, "ssh-dss", 7);
    p += 7;
    PUT_32BIT(p, plen);
    p += 4;
    for (i = plen; i--;)
	*p++ = bignum_byte(dss->p, i);
    PUT_32BIT(p, qlen);
    p += 4;
    for (i = qlen; i--;)
	*p++ = bignum_byte(dss->q, i);
    PUT_32BIT(p, glen);
    p += 4;
    for (i = glen; i--;)
	*p++ = bignum_byte(dss->g, i);
    PUT_32BIT(p, ylen);
    p += 4;
    for (i = ylen; i--;)
	*p++ = bignum_byte(dss->y, i);
    assert(p == blob + bloblen);
    *len = bloblen;
    return blob;
}

static unsigned char *dss_private_blob(void *key, int *len)
{
    return NULL;		       /* can't handle DSS private keys */
}

static void *dss_createkey(unsigned char *pub_blob, int pub_len,
			   unsigned char *priv_blob, int priv_len)
{
    return NULL;		       /* can't handle DSS private keys */
}

static void *dss_openssh_createkey(unsigned char **blob, int *len)
{
    return NULL;		       /* can't handle DSS private keys */
}

static int dss_openssh_fmtkey(void *key, unsigned char *blob, int len)
{
    return -1;			       /* can't handle DSS private keys */
}

unsigned char *dss_sign(void *key, char *data, int datalen, int *siglen)
{
    return NULL;		       /* can't handle DSS private keys */
}

const struct ssh_signkey ssh_dss = {
    dss_newkey,
    dss_freekey,
    dss_fmtkey,
    dss_public_blob,
    dss_private_blob,
    dss_createkey,
    dss_openssh_createkey,
    dss_openssh_fmtkey,
    dss_fingerprint,
    dss_verifysig,
    dss_sign,
    "ssh-dss",
    "dss"
};
Commit	Line	Data
7cca0d81	1	#include <stdio.h>
7cca0d81	2	#include <stdlib.h>
65a22376	3	#include <assert.h>
7cca0d81	4
e5574168	5	#include "ssh.h"
e5574168	6
7cca0d81	7	#define GET_32BIT(cp) \
	8	(((unsigned long)(unsigned char)(cp)[0] << 24) \| \
	9	((unsigned long)(unsigned char)(cp)[1] << 16) \| \
	10	((unsigned long)(unsigned char)(cp)[2] << 8) \| \
	11	((unsigned long)(unsigned char)(cp)[3]))
	12
d5859615	13	#define PUT_32BIT(cp, value) { \
	14	(cp)[0] = (unsigned char)((value) >> 24); \
	15	(cp)[1] = (unsigned char)((value) >> 16); \
	16	(cp)[2] = (unsigned char)((value) >> 8); \
	17	(cp)[3] = (unsigned char)(value); }
	18
9c621433	19	#if 0
c5fbd713	20	#define DEBUG_DSS
9c621433	21	#else
	22	#define diagbn(x,y)
	23	#endif
	24
32874aea	25	static void getstring(char *data, int datalen, char *p, int length)
32874aea	26	{
7cca0d81	27	*p = NULL;
7cca0d81	28	if (*datalen < 4)
32874aea	29	return;
7cca0d81	30	length = GET_32BIT(data);
32874aea	31	*datalen -= 4;
32874aea	32	*data += 4;
7cca0d81	33	if (datalen < length)
32874aea	34	return;
7cca0d81	35	p = data;
32874aea	36	data += length;
32874aea	37	datalen -= length;
7cca0d81	38	}
32874aea	39	static Bignum getmp(char *data, int datalen)
32874aea	40	{
7cca0d81	41	char *p;
3709bfe9	42	int length;
7cca0d81	43	Bignum b;
	44
	45	getstring(data, datalen, &p, &length);
	46	if (!p)
32874aea	47	return NULL;
7cca0d81	48	if (p[0] & 0x80)
32874aea	49	return NULL; /* negative mp */
3709bfe9	50	b = bignum_from_bytes(p, length);
7cca0d81	51	return b;
	52	}
	53
32874aea	54	static Bignum get160(char *data, int datalen)
32874aea	55	{
7cca0d81	56	Bignum b;
7cca0d81	57
3709bfe9	58	b = bignum_from_bytes(*data, 20);
32874aea	59	*data += 20;
32874aea	60	*datalen -= 20;
7cca0d81	61
7cca0d81	62	return b;
	63	}
	64
e055a386	65	struct dss_key {
	66	Bignum p, q, g, y;
	67	};
7cca0d81	68
32874aea	69	static void dss_newkey(char data, int len)
32874aea	70	{
7cca0d81	71	char *p;
7cca0d81	72	int slen;
e055a386	73	struct dss_key *dss;
e055a386	74
dcbde236	75	dss = smalloc(sizeof(struct dss_key));
32874aea	76	if (!dss)
32874aea	77	return NULL;
7cca0d81	78	getstring(&data, &len, &p, &slen);
9c621433	79
	80	#ifdef DEBUG_DSS
	81	{
32874aea	82	int i;
	83	printf("key:");
	84	for (i = 0; i < len; i++)
	85	printf(" %02x", (unsigned char) (data[i]));
	86	printf("\n");
9c621433	87	}
	88	#endif
	89
7cca0d81	90	if (!p \|\| memcmp(p, "ssh-dss", 7)) {
dcbde236	91	sfree(dss);
e055a386	92	return NULL;
7cca0d81	93	}
e055a386	94	dss->p = getmp(&data, &len);
	95	dss->q = getmp(&data, &len);
	96	dss->g = getmp(&data, &len);
	97	dss->y = getmp(&data, &len);
	98
	99	return dss;
7cca0d81	100	}
7cca0d81	101
32874aea	102	static void dss_freekey(void *key)
	103	{
	104	struct dss_key dss = (struct dss_key ) key;
e055a386	105	freebn(dss->p);
	106	freebn(dss->q);
	107	freebn(dss->g);
	108	freebn(dss->y);
dcbde236	109	sfree(dss);
e055a386	110	}
e055a386	111
32874aea	112	static char dss_fmtkey(void key)
	113	{
	114	struct dss_key dss = (struct dss_key ) key;
7cca0d81	115	char *p;
d5859615	116	int len, i, pos, nibbles;
d5859615	117	static const char hex[] = "0123456789abcdef";
e055a386	118	if (!dss->p)
32874aea	119	return NULL;
	120	len = 8 + 4 + 1; /* 4 x "0x", punctuation, \0 */
	121	len += 4 * (bignum_bitcount(dss->p) + 15) / 16;
	122	len += 4 * (bignum_bitcount(dss->q) + 15) / 16;
	123	len += 4 * (bignum_bitcount(dss->g) + 15) / 16;
	124	len += 4 * (bignum_bitcount(dss->y) + 15) / 16;
dcbde236	125	p = smalloc(len);
32874aea	126	if (!p)
32874aea	127	return NULL;
d5859615	128
d5859615	129	pos = 0;
32874aea	130	pos += sprintf(p + pos, "0x");
	131	nibbles = (3 + bignum_bitcount(dss->p)) / 4;
	132	if (nibbles < 1)
	133	nibbles = 1;
	134	for (i = nibbles; i--;)
	135	p[pos++] =
	136	hex[(bignum_byte(dss->p, i / 2) >> (4 * (i % 2))) & 0xF];
	137	pos += sprintf(p + pos, ",0x");
	138	nibbles = (3 + bignum_bitcount(dss->q)) / 4;
	139	if (nibbles < 1)
	140	nibbles = 1;
	141	for (i = nibbles; i--;)
	142	p[pos++] =
	143	hex[(bignum_byte(dss->q, i / 2) >> (4 * (i % 2))) & 0xF];
	144	pos += sprintf(p + pos, ",0x");
	145	nibbles = (3 + bignum_bitcount(dss->g)) / 4;
	146	if (nibbles < 1)
	147	nibbles = 1;
	148	for (i = nibbles; i--;)
	149	p[pos++] =
	150	hex[(bignum_byte(dss->g, i / 2) >> (4 * (i % 2))) & 0xF];
	151	pos += sprintf(p + pos, ",0x");
	152	nibbles = (3 + bignum_bitcount(dss->y)) / 4;
	153	if (nibbles < 1)
	154	nibbles = 1;
	155	for (i = nibbles; i--;)
	156	p[pos++] =
	157	hex[(bignum_byte(dss->y, i / 2) >> (4 * (i % 2))) & 0xF];
d5859615	158	p[pos] = '\0';
7cca0d81	159	return p;
	160	}
	161
32874aea	162	static char dss_fingerprint(void key)
	163	{
	164	struct dss_key dss = (struct dss_key ) key;
d5859615	165	struct MD5Context md5c;
d5859615	166	unsigned char digest[16], lenbuf[4];
32874aea	167	char buffer[16 * 3 + 40];
d5859615	168	char *ret;
	169	int numlen, i;
	170
	171	MD5Init(&md5c);
	172	MD5Update(&md5c, "\0\0\0\7ssh-dss", 11);
	173
	174	#define ADD_BIGNUM(bignum) \
ddecd643	175	numlen = (bignum_bitcount(bignum)+8)/8; \
d5859615	176	PUT_32BIT(lenbuf, numlen); MD5Update(&md5c, lenbuf, 4); \
	177	for (i = numlen; i-- ;) { \
	178	unsigned char c = bignum_byte(bignum, i); \
	179	MD5Update(&md5c, &c, 1); \
	180	}
e055a386	181	ADD_BIGNUM(dss->p);
	182	ADD_BIGNUM(dss->q);
	183	ADD_BIGNUM(dss->g);
	184	ADD_BIGNUM(dss->y);
d5859615	185	#undef ADD_BIGNUM
	186
	187	MD5Final(digest, &md5c);
	188
ddecd643	189	sprintf(buffer, "ssh-dss %d ", bignum_bitcount(dss->p));
d5859615	190	for (i = 0; i < 16; i++)
32874aea	191	sprintf(buffer + strlen(buffer), "%s%02x", i ? ":" : "",
	192	digest[i]);
	193	ret = smalloc(strlen(buffer) + 1);
d5859615	194	if (ret)
32874aea	195	strcpy(ret, buffer);
d5859615	196	return ret;
	197	}
	198
e055a386	199	static int dss_verifysig(void key, char sig, int siglen,
32874aea	200	char *data, int datalen)
	201	{
	202	struct dss_key dss = (struct dss_key ) key;
7cca0d81	203	char *p;
c5fbd713	204	int slen;
7cca0d81	205	char hash[20];
59600f67	206	Bignum r, s, w, gu1p, yu2p, gu1yu2p, u1, u2, sha, v;
7cca0d81	207	int ret;
7cca0d81	208
e055a386	209	if (!dss->p)
32874aea	210	return 0;
7cca0d81	211
9c621433	212	#ifdef DEBUG_DSS
9c621433	213	{
32874aea	214	int i;
	215	printf("sig:");
	216	for (i = 0; i < siglen; i++)
	217	printf(" %02x", (unsigned char) (sig[i]));
	218	printf("\n");
9c621433	219	}
9c621433	220	#endif
7f7837c8	221	/*
	222	* Commercial SSH (2.0.13) and OpenSSH disagree over the format
	223	* of a DSA signature. OpenSSH is in line with the IETF drafts:
	224	* it uses a string "ssh-dss", followed by a 40-byte string
	225	* containing two 160-bit integers end-to-end. Commercial SSH
	226	* can't be bothered with the header bit, and considers a DSA
	227	* signature blob to be _just_ the 40-byte string containing
	228	* the two 160-bit integers. We tell them apart by measuring
	229	* the length: length 40 means the commercial-SSH bug, anything
	230	* else is assumed to be IETF-compliant.
	231	*/
32874aea	232	if (siglen != 40) { /* bug not present; read admin fields */
	233	getstring(&sig, &siglen, &p, &slen);
	234	if (!p \|\| slen != 7 \|\| memcmp(p, "ssh-dss", 7)) {
	235	return 0;
	236	}
	237	sig += 4, siglen -= 4; /* skip yet another length field */
7cca0d81	238	}
e055a386	239	diagbn("p=", dss->p);
	240	diagbn("q=", dss->q);
	241	diagbn("g=", dss->g);
	242	diagbn("y=", dss->y);
7cca0d81	243	r = get160(&sig, &siglen);
9c621433	244	diagbn("r=", r);
7cca0d81	245	s = get160(&sig, &siglen);
9c621433	246	diagbn("s=", s);
7cca0d81	247	if (!r \|\| !s)
32874aea	248	return 0;
7cca0d81	249
	250	/*
	251	* Step 1. w <- s^-1 mod q.
	252	*/
e055a386	253	w = modinv(s, dss->q);
9c621433	254	diagbn("w=", w);
7cca0d81	255
	256	/*
	257	* Step 2. u1 <- SHA(message) * w mod q.
	258	*/
7cca0d81	259	SHA_Simple(data, datalen, hash);
32874aea	260	p = hash;
	261	slen = 20;
	262	sha = get160(&p, &slen);
9c621433	263	diagbn("sha=", sha);
e055a386	264	u1 = modmul(sha, w, dss->q);
9c621433	265	diagbn("u1=", u1);
7cca0d81	266
	267	/*
	268	* Step 3. u2 <- r * w mod q.
	269	*/
e055a386	270	u2 = modmul(r, w, dss->q);
9c621433	271	diagbn("u2=", u2);
7cca0d81	272
	273	/*
	274	* Step 4. v <- (g^u1 * y^u2 mod p) mod q.
	275	*/
e055a386	276	gu1p = modpow(dss->g, u1, dss->p);
59600f67	277	diagbn("gu1p=", gu1p);
e055a386	278	yu2p = modpow(dss->y, u2, dss->p);
59600f67	279	diagbn("yu2p=", yu2p);
e055a386	280	gu1yu2p = modmul(gu1p, yu2p, dss->p);
59600f67	281	diagbn("gu1yu2p=", gu1yu2p);
e055a386	282	v = modmul(gu1yu2p, One, dss->q);
9c621433	283	diagbn("gu1yu2q=v=", v);
9c621433	284	diagbn("r=", r);
7cca0d81	285
	286	/*
	287	* Step 5. v should now be equal to r.
	288	*/
	289
c5fbd713	290	ret = !bignum_cmp(v, r);
7cca0d81	291
7cca0d81	292	freebn(w);
7cca0d81	293	freebn(sha);
59600f67	294	freebn(gu1p);
	295	freebn(yu2p);
	296	freebn(gu1yu2p);
7cca0d81	297	freebn(v);
	298	freebn(r);
	299	freebn(s);
	300
	301	return ret;
	302	}
	303
32874aea	304	static unsigned char dss_public_blob(void key, int *len)
	305	{
	306	struct dss_key dss = (struct dss_key ) key;
65a22376	307	int plen, qlen, glen, ylen, bloblen;
	308	int i;
	309	unsigned char blob, p;
	310
32874aea	311	plen = (bignum_bitcount(dss->p) + 8) / 8;
	312	qlen = (bignum_bitcount(dss->q) + 8) / 8;
	313	glen = (bignum_bitcount(dss->g) + 8) / 8;
	314	ylen = (bignum_bitcount(dss->y) + 8) / 8;
65a22376	315
	316	/*
	317	* string "ssh-dss", mpint p, mpint q, mpint g, mpint y. Total
	318	* 27 + sum of lengths. (five length fields, 20+7=27).
	319	*/
32874aea	320	bloblen = 27 + plen + qlen + glen + ylen;
65a22376	321	blob = smalloc(bloblen);
65a22376	322	p = blob;
32874aea	323	PUT_32BIT(p, 7);
	324	p += 4;
	325	memcpy(p, "ssh-dss", 7);
	326	p += 7;
	327	PUT_32BIT(p, plen);
	328	p += 4;
	329	for (i = plen; i--;)
	330	*p++ = bignum_byte(dss->p, i);
	331	PUT_32BIT(p, qlen);
	332	p += 4;
	333	for (i = qlen; i--;)
	334	*p++ = bignum_byte(dss->q, i);
	335	PUT_32BIT(p, glen);
	336	p += 4;
	337	for (i = glen; i--;)
	338	*p++ = bignum_byte(dss->g, i);
	339	PUT_32BIT(p, ylen);
	340	p += 4;
	341	for (i = ylen; i--;)
	342	*p++ = bignum_byte(dss->y, i);
65a22376	343	assert(p == blob + bloblen);
	344	*len = bloblen;
	345	return blob;
	346	}
	347
32874aea	348	static unsigned char dss_private_blob(void key, int *len)
32874aea	349	{
65a22376	350	return NULL; /* can't handle DSS private keys */
	351	}
	352
	353	static void dss_createkey(unsigned char pub_blob, int pub_len,
32874aea	354	unsigned char *priv_blob, int priv_len)
32874aea	355	{
65a22376	356	return NULL; /* can't handle DSS private keys */
	357	}
	358
32874aea	359	static void dss_openssh_createkey(unsigned char blob, int len)
32874aea	360	{
45cebe79	361	return NULL; /* can't handle DSS private keys */
	362	}
	363
32874aea	364	static int dss_openssh_fmtkey(void key, unsigned char blob, int len)
32874aea	365	{
ddecd643	366	return -1; /* can't handle DSS private keys */
	367	}
	368
32874aea	369	unsigned char dss_sign(void key, char data, int datalen, int siglen)
32874aea	370	{
65a22376	371	return NULL; /* can't handle DSS private keys */
e055a386	372	}
e055a386	373
65a22376	374	const struct ssh_signkey ssh_dss = {
e055a386	375	dss_newkey,
e055a386	376	dss_freekey,
7cca0d81	377	dss_fmtkey,
65a22376	378	dss_public_blob,
	379	dss_private_blob,
	380	dss_createkey,
45cebe79	381	dss_openssh_createkey,
ddecd643	382	dss_openssh_fmtkey,
d5859615	383	dss_fingerprint,
7cca0d81	384	dss_verifysig,
e055a386	385	dss_sign,
d5859615	386	"ssh-dss",
d5859615	387	"dss"
e5574168	388	};