rdpproxy/trunk/rsa2der.c

#include <stdio.h>
#include <string.h>
#include <unistd.h>
#include <fcntl.h>
#include <openssl/rsa.h>

/* reverse an array in situ */
void
reverse(unsigned char *p, unsigned int len)
{
        char temp;
        int i, j;

        for (i = 0, j = len - 1; i < j; i++, j--)
        {
                temp = p[i];
                p[i] = p[j];
                p[j] = temp;
        }
}

int
read_file(char *filename, unsigned char *buffer, unsigned int maxlen)
{
        int fd, len;

        fd = open(filename, O_RDONLY);
        if (fd == -1)
        {
                perror(filename);
                return -1;
        }

        len = read(fd, buffer, maxlen);
        close(fd);
        return len;
}

int
write_file(char *filename, unsigned char *buffer, unsigned int len)
{
        int fd;

        fd = open(filename, O_WRONLY | O_CREAT | O_TRUNC, 0600);
        if (fd == -1)
        {
                perror(filename);
                return -1;
        }

        len = write(fd, buffer, len);
        close(fd);
        return len;
}

BIGNUM *
parse_bignum(unsigned char **buf, unsigned int len)
{
        BIGNUM *bn;

        reverse(*buf, len);
        bn = BN_bin2bn(*buf, len, NULL);
        *buf += len;

        return bn;
}

RSA *
parse_rsa2(unsigned char *buf, unsigned int len)
{
        RSA *rsa;
        unsigned int modlen;

        if (strncmp(buf, "RSA2", 4) != 0)
        {
                fprintf(stderr, "Not an RSA2 private key\n");
                return NULL;
        }

        /* FIXME: should be a DWORD */
        modlen = *(buf + 4);
        if (len < (20 + (9 * modlen / 2)))
        {
                fprintf(stderr, "Input file truncated?\n");
                return NULL;
        }

        buf += 16;

        rsa = RSA_new();
        if (rsa == NULL)
                return NULL;

        rsa->e = parse_bignum(&buf, 4);
        rsa->n = parse_bignum(&buf, modlen);
        rsa->p = parse_bignum(&buf, modlen / 2);
        rsa->q = parse_bignum(&buf, modlen / 2);
        rsa->dmp1 = parse_bignum(&buf, modlen / 2);
        rsa->dmq1 = parse_bignum(&buf, modlen / 2);
        rsa->iqmp = parse_bignum(&buf, modlen / 2);
        rsa->d = parse_bignum(&buf, modlen);

        return rsa;
}

int
main(int argc, char *argv[])
{
        unsigned char buffer[1024];
        unsigned char *p = buffer;
        unsigned int len;
        RSA *rsa;

        if (argc < 3)
        {
                fprintf(stderr, "Usage: %s <infile> <outfile>\n", argv[0]);
                return 0;
        }

        if ((len = read_file(argv[1], buffer, sizeof(buffer))) == -1)
        {
                fprintf(stderr, "Failed to read file\n");
                return 1;
        }

        if ((rsa = parse_rsa2(buffer, len)) == NULL)
        {
                fprintf(stderr, "Failed to parse RSA key\n");
                return 1;
        }

        len = i2d_RSAPrivateKey(rsa, &p);
        if (write_file(argv[2], buffer, len) == -1)
        {
                fprintf(stderr, "Failed to write file\n");
                return 1;
        }

        return 0;
}
1	forsberg	429	#include <stdio.h>
2			#include <string.h>
3			#include <unistd.h>
4			#include <fcntl.h>
5			#include <openssl/rsa.h>
6
7			/* reverse an array in situ */
8			void
9			reverse(unsigned char *p, unsigned int len)
10			{
11			char temp;
12			int i, j;
13
14			for (i = 0, j = len - 1; i < j; i++, j--)
15			{
16			temp = p[i];
17			p[i] = p[j];
18			p[j] = temp;
19			}
20			}
21
22			int
23			read_file(char filename, unsigned char buffer, unsigned int maxlen)
24			{
25			int fd, len;
26
27			fd = open(filename, O_RDONLY);
28			if (fd == -1)
29			{
30			perror(filename);
31			return -1;
32			}
33
34			len = read(fd, buffer, maxlen);
35			close(fd);
36			return len;
37			}
38
39			int
40			write_file(char filename, unsigned char buffer, unsigned int len)
41			{
42			int fd;
43
44			fd = open(filename, O_WRONLY \| O_CREAT \| O_TRUNC, 0600);
45			if (fd == -1)
46			{
47			perror(filename);
48			return -1;
49			}
50
51			len = write(fd, buffer, len);
52			close(fd);
53			return len;
54			}
55
56			BIGNUM *
57			parse_bignum(unsigned char **buf, unsigned int len)
58			{
59			BIGNUM *bn;
60
61			reverse(*buf, len);
62			bn = BN_bin2bn(*buf, len, NULL);
63			*buf += len;
64
65			return bn;
66			}
67
68			RSA *
69			parse_rsa2(unsigned char *buf, unsigned int len)
70			{
71			RSA *rsa;
72			unsigned int modlen;
73
74			if (strncmp(buf, "RSA2", 4) != 0)
75			{
76			fprintf(stderr, "Not an RSA2 private key\n");
77			return NULL;
78			}
79
80			/* FIXME: should be a DWORD */
81			modlen = *(buf + 4);
82			if (len < (20 + (9 * modlen / 2)))
83			{
84			fprintf(stderr, "Input file truncated?\n");
85			return NULL;
86			}
87
88			buf += 16;
89
90			rsa = RSA_new();
91			if (rsa == NULL)
92			return NULL;
93
94			rsa->e = parse_bignum(&buf, 4);
95			rsa->n = parse_bignum(&buf, modlen);
96			rsa->p = parse_bignum(&buf, modlen / 2);
97			rsa->q = parse_bignum(&buf, modlen / 2);
98			rsa->dmp1 = parse_bignum(&buf, modlen / 2);
99			rsa->dmq1 = parse_bignum(&buf, modlen / 2);
100			rsa->iqmp = parse_bignum(&buf, modlen / 2);
101			rsa->d = parse_bignum(&buf, modlen);
102
103			return rsa;
104			}
105
106			int
107			main(int argc, char *argv[])
108			{
109			unsigned char buffer[1024];
110			unsigned char *p = buffer;
111			unsigned int len;
112			RSA *rsa;
113
114			if (argc < 3)
115			{
116			fprintf(stderr, "Usage: %s <infile> <outfile>\n", argv[0]);
117			return 0;
118			}
119
120			if ((len = read_file(argv[1], buffer, sizeof(buffer))) == -1)
121			{
122			fprintf(stderr, "Failed to read file\n");
123			return 1;
124			}
125
126			if ((rsa = parse_rsa2(buffer, len)) == NULL)
127			{
128			fprintf(stderr, "Failed to parse RSA key\n");
129			return 1;
130			}
131
132			len = i2d_RSAPrivateKey(rsa, &p);
133			if (write_file(argv[2], buffer, len) == -1)
134			{
135			fprintf(stderr, "Failed to write file\n");
136			return 1;
137			}
138
139			return 0;
140			}