tinc-vpn.org Git - tinc/blob - src/gcrypt/rsagen.c

   1 /*
   2     rsagen.c -- RSA key generation and export
   3     Copyright (C) 2008 Guus Sliepen <guus@tinc-vpn.org>
   4
   5     This program is free software; you can redistribute it and/or modify
   6     it under the terms of the GNU General Public License as published by
   7     the Free Software Foundation; either version 2 of the License, or
   8     (at your option) any later version.
   9
  10     This program is distributed in the hope that it will be useful,
  11     but WITHOUT ANY WARRANTY; without even the implied warranty of
  12     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13     GNU General Public License for more details.
  14
  15     You should have received a copy of the GNU General Public License
  16     along with this program; if not, write to the Free Software
  17     Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  18
  19     $Id$
  20 */
  21
  22 #include "system.h"
  23
  24 #include <gcrypt.h>
  25
  26 #include "rsagen.h"
  27
  28 #if 0
  29 // Base64 encoding table
  30
  31 static const char b64e[64] = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
  32
  33 // PEM encoding
  34
  35 static bool pem_encode(FILE *fp, const char *header, uint8_t *buf, size_t size) {
  36         bool decode = false;
  37         char line[1024];
  38         uint32_t word = 0;
  39         int shift = 0;
  40         size_t i, j = 0;
  41
  42         fprintf(fp, "-----BEGIN %s-----\n", header);
  43
  44         for(i = 0; i < size; i += 3) {
  45                 if(i <= size - 3) {
  46                         word = buf[i] << 16 | buf[i + 1] << 8 | buf[i + 2];
  47                 } else {
  48                         word = buf[i] << 16;
  49                         if(i == size - 2)
  50                                 word |= buf[i + 1] << 8;
  51                 }
  52
  53                 line[j++] = b64e[(word >> 18)       ];
  54                 line[j++] = b64e[(word >> 12) & 0x3f];
  55                 line[j++] = b64e[(word >>  6) & 0x3f];
  56                 line[j++] = b64e[(word      ) & 0x3f];
  57
  58                 if(j >= 64) {
  59                         line[j++] = '\n';
  60                         line[j] = 0;
  61                         fputs(line, fp);
  62                         j = 0;
  63                 }
  64         }
  65
  66         if(size % 3 > 0) {
  67                 if(size % 3 > 1)
  68                         line[j++] = '=';
  69                 line[j++] = '=';
  70         }
  71
  72         if(j) {
  73                 line[j++] = '\n';
  74                 line[j] = 0;
  75                 fputs(line, fp);
  76         }
  77
  78         fprintf(fp, "-----END %s-----\n", header);
  79
  80         return true;
  81 }
  82
  83
  84 // BER encoding functions
  85
  86 static bool ber_write_id(uint8_t **p, size_t *buflen, int id) {
  87         if(*buflen <= 0)
  88                 return false;
  89
  90         if(id >= 0x1f) {
  91                 while(id) {
  92                         if(*buflen <= 0)
  93                                 return false;
  94
  95                         (*buflen)--;
  96                         **p = id & 0x7f;
  97                         id >>= 7;
  98                         if(id)
  99                                 **p |= 0x80;
 100                         (*p)++;
 101                 }
 102         } else {
 103                 (*buflen)--;
 104                 *(*p)++ = id;
 105         }
 106
 107         return true;
 108 }
 109
 110 static bool ber_write_len(uint8_t **p, size_t *buflen, size_t len) {
 111         do {
 112                 if(*buflen <= 0)
 113                         return false;
 114
 115                 (*buflen)--;
 116                 **p = len & 0x7f;
 117                 len >>= 7;
 118                 if(len)
 119                         **p |= 0x80;
 120                 (*p)++;
 121         } while(len);
 122
 123         return true;
 124 }
 125
 126 static bool ber_write_sequence(uint8_t **p, size_t *buflen, uint8_t *seqbuf, size_t seqlen) {
 127         if(!ber_write_id(p, buflen, 0x10) || !ber_write_len(p, buflen, seqlen) || *buflen < seqlen)
 128                 return false;
 129
 130         memcpy(*p, seqbuf, seqlen);
 131         *p += seqlen;
 132         *buflen -= seqlen;
 133
 134         return true;
 135 }
 136
 137 static bool ber_write_mpi(uint8_t **p, size_t *buflen, gcry_mpi_t mpi) {
 138         uint8_t tmpbuf[1024];
 139         size_t tmplen = sizeof tmpbuf;
 140         gcry_error_t err;
 141
 142         err = gcry_mpi_aprint(GCRYMPI_FMT_USG, &tmpbuf, &tmplen, mpi);
 143         if(err)
 144                 return false;
 145
 146         if(!ber_write_id(p, buflen, 0x02) || !ber_write_len(p, buflen, tmplen) || *buflen < tmplen)
 147                 return false;
 148
 149         memcpy(*p, tmpbuf, tmplen);
 150         *p += tmplen;
 151         *buflen -= tmplen;
 152
 153         return true;
 154 }
 155
 156 // Write PEM RSA keys
 157
 158 bool rsa_write_pem_public_key(rsa_t *rsa, FILE *fp) {
 159         uint8_t derbuf1[8096];
 160         uint8_t derbuf2[8096];
 161         uint8_t *derp1 = derbuf1;
 162         uint8_t *derp2 = derbuf2;
 163         size_t derlen1 = sizeof derbuf1;
 164         size_t derlen2 = sizeof derbuf2;
 165
 166         if(!ber_write_mpi(&derp1, &derlen1, &rsa->n)
 167                         || !ber_write_mpi(&derp1, &derlen1, &rsa->e)
 168                         || !ber_write_sequence(&derp2, &derlen2, derbuf1, derlen1)) {
 169                 logger(LOG_ERR, _("Error while encoding RSA public key"));
 170                 return false;
 171         }
 172
 173         if(!pem_encode(fp, "RSA PUBLIC KEY", derbuf2, derlen2)) {
 174                 logger(LOG_ERR, _("Unable to write RSA public key: %s"), strerror(errno));
 175                 return false;
 176         }
 177
 178         return true;
 179 }
 180
 181 bool rsa_write_pem_private_key(rsa_t *rsa, FILE *fp) {
 182         uint8_t derbuf1[8096];
 183         uint8_t derbuf2[8096];
 184         uint8_t *derp1 = derbuf1;
 185         uint8_t *derp2 = derbuf2;
 186         size_t derlen1 = sizeof derbuf1;
 187         size_t derlen2 = sizeof derbuf2;
 188
 189         if(!ber_write_mpi(&derp1, &derlen1, &bits)
 190                         || ber_write_mpi(&derp1, &derlen1, &rsa->n) // modulus
 191                         || ber_write_mpi(&derp1, &derlen1, &rsa->e) // public exponent
 192                         || ber_write_mpi(&derp1, &derlen1, &rsa->d) // private exponent
 193                         || ber_write_mpi(&derp1, &derlen1, &p)
 194                         || ber_write_mpi(&derp1, &derlen1, &q)
 195                         || ber_write_mpi(&derp1, &derlen1, &exp1)
 196                         || ber_write_mpi(&derp1, &derlen1, &exp2)
 197                         || ber_write_mpi(&derp1, &derlen1, &coeff))
 198                 logger(LOG_ERR, _("Error while encoding RSA private key"));
 199                 return false;
 200         }
 201
 202         if(!pem_encode(fp, "RSA PRIVATE KEY", derbuf2, derlen2)) {
 203                 logger(LOG_ERR, _("Unable to write RSA private key: %s"), strerror(errno));
 204                 return false;
 205         }
 206
 207         return true;
 208 }
 209 #endif
 210
 211 bool rsa_write_pem_public_key(rsa_t *rsa, FILE *fp) {
 212         return false;
 213 }
 214
 215 bool rsa_write_pem_private_key(rsa_t *rsa, FILE *fp) {
 216         return false;
 217 }
 218
 219 bool rsa_generate(rsa_t *rsa, size_t bits, unsigned long exponent) {
 220         fprintf(stderr, _("Generating RSA keys with libgcrypt not implemented yet\n"));
 221         return false;
 222 }