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

   1 /*
   2     rsagen.c -- RSA key generation and export
   3     Copyright (C) 2008-2012 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 along
  16     with this program; if not, write to the Free Software Foundation, Inc.,
  17     51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  18 */
  19
  20 #include "system.h"
  21
  22 #include <gcrypt.h>
  23
  24 #include "rsagen.h"
  25
  26 #if 0
  27 // Base64 encoding table
  28
  29 static const char b64e[64] = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
  30
  31 // PEM encoding
  32
  33 static bool pem_encode(FILE *fp, const char *header, uint8_t *buf, size_t size) {
  34         bool decode = false;
  35         char line[1024];
  36         uint32_t word = 0;
  37         int shift = 0;
  38         size_t i, j = 0;
  39
  40         fprintf(fp, "-----BEGIN %s-----\n", header);
  41
  42         for(i = 0; i < size; i += 3) {
  43                 if(i <= size - 3) {
  44                         word = buf[i] << 16 | buf[i + 1] << 8 | buf[i + 2];
  45                 } else {
  46                         word = buf[i] << 16;
  47
  48                         if(i == size - 2) {
  49                                 word |= buf[i + 1] << 8;
  50                         }
  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                 }
  70
  71                 line[j++] = '=';
  72         }
  73
  74         if(j) {
  75                 line[j++] = '\n';
  76                 line[j] = 0;
  77                 fputs(line, fp);
  78         }
  79
  80         fprintf(fp, "-----END %s-----\n", header);
  81
  82         return true;
  83 }
  84
  85
  86 // BER encoding functions
  87
  88 static bool ber_write_id(uint8_t **p, size_t *buflen, int id) {
  89         if(*buflen <= 0) {
  90                 return false;
  91         }
  92
  93         if(id >= 0x1f) {
  94                 while(id) {
  95                         if(*buflen <= 0) {
  96                                 return false;
  97                         }
  98
  99                         (*buflen)--;
 100                         **p = id & 0x7f;
 101                         id >>= 7;
 102
 103                         if(id) {
 104                                 **p |= 0x80;
 105                         }
 106
 107                         (*p)++;
 108                 }
 109         } else {
 110                 (*buflen)--;
 111                 *(*p)++ = id;
 112         }
 113
 114         return true;
 115 }
 116
 117 static bool ber_write_len(uint8_t **p, size_t *buflen, size_t len) {
 118         do {
 119                 if(*buflen <= 0) {
 120                         return false;
 121                 }
 122
 123                 (*buflen)--;
 124                 **p = len & 0x7f;
 125                 len >>= 7;
 126
 127                 if(len) {
 128                         **p |= 0x80;
 129                 }
 130
 131                 (*p)++;
 132         } while(len);
 133
 134         return true;
 135 }
 136
 137 static bool ber_write_sequence(uint8_t **p, size_t *buflen, uint8_t *seqbuf, size_t seqlen) {
 138         if(!ber_write_id(p, buflen, 0x10) || !ber_write_len(p, buflen, seqlen) || *buflen < seqlen) {
 139                 return false;
 140         }
 141
 142         memcpy(*p, seqbuf, seqlen);
 143         *p += seqlen;
 144         *buflen -= seqlen;
 145
 146         return true;
 147 }
 148
 149 static bool ber_write_mpi(uint8_t **p, size_t *buflen, gcry_mpi_t mpi) {
 150         uint8_t tmpbuf[1024];
 151         size_t tmplen = sizeof(tmpbuf);
 152         gcry_error_t err;
 153
 154         err = gcry_mpi_aprint(GCRYMPI_FMT_USG, &tmpbuf, &tmplen, mpi);
 155
 156         if(err) {
 157                 return false;
 158         }
 159
 160         if(!ber_write_id(p, buflen, 0x02) || !ber_write_len(p, buflen, tmplen) || *buflen < tmplen) {
 161                 return false;
 162         }
 163
 164         memcpy(*p, tmpbuf, tmplen);
 165         *p += tmplen;
 166         *buflen -= tmplen;
 167
 168         return true;
 169 }
 170
 171 // Write PEM RSA keys
 172
 173 bool rsa_write_pem_public_key(rsa_t *rsa, FILE *fp) {
 174         uint8_t derbuf1[8096];
 175         uint8_t derbuf2[8096];
 176         uint8_t *derp1 = derbuf1;
 177         uint8_t *derp2 = derbuf2;
 178         size_t derlen1 = sizeof(derbuf1);
 179         size_t derlen2 = sizeof(derbuf2);
 180
 181         if(!ber_write_mpi(&derp1, &derlen1, &rsa->n)
 182                         || !ber_write_mpi(&derp1, &derlen1, &rsa->e)
 183                         || !ber_write_sequence(&derp2, &derlen2, derbuf1, derlen1)) {
 184                 logger(DEBUG_ALWAYS, LOG_ERR, "Error while encoding RSA public key");
 185                 return false;
 186         }
 187
 188         if(!pem_encode(fp, "RSA PUBLIC KEY", derbuf2, derlen2)) {
 189                 logger(DEBUG_ALWAYS, LOG_ERR, "Unable to write RSA public key: %s", strerror(errno));
 190                 return false;
 191         }
 192
 193         return true;
 194 }
 195
 196 bool rsa_write_pem_private_key(rsa_t *rsa, FILE *fp) {
 197         uint8_t derbuf1[8096];
 198         uint8_t derbuf2[8096];
 199         uint8_t *derp1 = derbuf1;
 200         uint8_t *derp2 = derbuf2;
 201         size_t derlen1 = sizeof(derbuf1);
 202         size_t derlen2 = sizeof(derbuf2);
 203
 204         if(!ber_write_mpi(&derp1, &derlen1, &bits)
 205                         || ber_write_mpi(&derp1, &derlen1, &rsa->n) // modulus
 206                         || ber_write_mpi(&derp1, &derlen1, &rsa->e) // public exponent
 207                         || ber_write_mpi(&derp1, &derlen1, &rsa->d) // private exponent
 208                         || ber_write_mpi(&derp1, &derlen1, &p)
 209                         || ber_write_mpi(&derp1, &derlen1, &q)
 210                         || ber_write_mpi(&derp1, &derlen1, &exp1)
 211                         || ber_write_mpi(&derp1, &derlen1, &exp2)
 212                         || ber_write_mpi(&derp1, &derlen1, &coeff)) {
 213                 logger(DEBUG_ALWAYS, LOG_ERR, "Error while encoding RSA private key");
 214         }
 215
 216         return false;
 217 }
 218
 219 if(!pem_encode(fp, "RSA PRIVATE KEY", derbuf2, derlen2)) {
 220         logger(DEBUG_ALWAYS, LOG_ERR, "Unable to write RSA private key: %s", strerror(errno));
 221         return false;
 222 }
 223
 224 return true;
 225 }
 226 #endif
 227
 228 bool rsa_write_pem_public_key(rsa_t *rsa, FILE *fp) {
 229         return false;
 230 }
 231
 232 bool rsa_write_pem_private_key(rsa_t *rsa, FILE *fp) {
 233         return false;
 234 }
 235
 236 bool rsa_generate(rsa_t *rsa, size_t bits, unsigned long exponent) {
 237         fprintf(stderr, "Generating RSA keys with libgcrypt not implemented yet\n");
 238         return false;
 239 }