crypto/rsakey-builtin.c.inc

   1 /*
   2  * QEMU Crypto akcipher algorithms
   3  *
   4  * Copyright (c) 2022 Bytedance
   5  * Author: lei he <helei.sig11@bytedance.com>
   6  *
   7  * This library is free software; you can redistribute it and/or
   8  * modify it under the terms of the GNU Lesser General Public
   9  * License as published by the Free Software Foundation; either
  10  * version 2.1 of the License, or (at your option) any later version.
  11  *
  12  * This library is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  * Lesser General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU Lesser General Public
  18  * License along with this library; if not, see <http://www.gnu.org/licenses/>.
  19  *
  20  */
  21
  22 #include "der.h"
  23 #include "rsakey.h"
  24
  25 static int extract_mpi(void *ctx, const uint8_t *value,
  26                        size_t vlen, Error **errp)
  27 {
  28     QCryptoAkCipherMPI *mpi = (QCryptoAkCipherMPI *)ctx;
  29     if (vlen == 0) {
  30         error_setg(errp, "Empty mpi field");
  31         return -1;
  32     }
  33     mpi->data = g_memdup2(value, vlen);
  34     mpi->len = vlen;
  35     return 0;
  36 }
  37
  38 static int extract_version(void *ctx, const uint8_t *value,
  39                            size_t vlen, Error **errp)
  40 {
  41     uint8_t *version = (uint8_t *)ctx;
  42     if (vlen != 1 || *value > 1) {
  43         error_setg(errp, "Invalid rsakey version");
  44         return -1;
  45     }
  46     *version = *value;
  47     return 0;
  48 }
  49
  50 static int extract_seq_content(void *ctx, const uint8_t *value,
  51                                size_t vlen, Error **errp)
  52 {
  53     const uint8_t **content = (const uint8_t **)ctx;
  54     if (vlen == 0) {
  55         error_setg(errp, "Empty sequence");
  56         return -1;
  57     }
  58     *content = value;
  59     return 0;
  60 }
  61
  62 /**
  63  *
  64  *        RsaPubKey ::= SEQUENCE {
  65  *             n           INTEGER
  66  *             e           INTEGER
  67  *         }
  68  */
  69 static QCryptoAkCipherRSAKey *qcrypto_builtin_rsa_public_key_parse(
  70     const uint8_t *key, size_t keylen, Error **errp)
  71 {
  72     QCryptoAkCipherRSAKey *rsa = g_new0(QCryptoAkCipherRSAKey, 1);
  73     const uint8_t *seq;
  74     size_t seq_length;
  75     int decode_ret;
  76
  77     decode_ret = qcrypto_der_decode_seq(&key, &keylen,
  78                                         extract_seq_content, &seq, errp);
  79     if (decode_ret < 0 || keylen != 0) {
  80         goto error;
  81     }
  82     seq_length = decode_ret;
  83
  84     if (qcrypto_der_decode_int(&seq, &seq_length, extract_mpi,
  85                                &rsa->n, errp) < 0 ||
  86         qcrypto_der_decode_int(&seq, &seq_length, extract_mpi,
  87                                &rsa->e, errp) < 0) {
  88         goto error;
  89     }
  90     if (seq_length != 0) {
  91         goto error;
  92     }
  93
  94     return rsa;
  95
  96 error:
  97     if (errp && !*errp) {
  98         error_setg(errp, "Invalid RSA public key");
  99     }
 100     qcrypto_akcipher_rsakey_free(rsa);
 101     return NULL;
 102 }
 103
 104 /**
 105  *        RsaPrivKey ::= SEQUENCE {
 106  *             version     INTEGER
 107  *             n           INTEGER
 108  *             e           INTEGER
 109  *             d           INTEGER
 110  *             p           INTEGER
 111  *             q           INTEGER
 112  *             dp          INTEGER
 113  *             dq          INTEGER
 114  *             u           INTEGER
 115  *       otherPrimeInfos   OtherPrimeInfos OPTIONAL
 116  *         }
 117  */
 118 static QCryptoAkCipherRSAKey *qcrypto_builtin_rsa_private_key_parse(
 119     const uint8_t *key, size_t keylen, Error **errp)
 120 {
 121     QCryptoAkCipherRSAKey *rsa = g_new0(QCryptoAkCipherRSAKey, 1);
 122     uint8_t version;
 123     const uint8_t *seq;
 124     int decode_ret;
 125     size_t seq_length;
 126
 127     decode_ret = qcrypto_der_decode_seq(&key, &keylen, extract_seq_content,
 128                                         &seq, errp);
 129     if (decode_ret < 0 || keylen != 0) {
 130         goto error;
 131     }
 132     seq_length = decode_ret;
 133
 134     decode_ret = qcrypto_der_decode_int(&seq, &seq_length, extract_version,
 135                                         &version, errp);
 136
 137     if (qcrypto_der_decode_int(&seq, &seq_length, extract_mpi,
 138                                &rsa->n, errp) < 0 ||
 139         qcrypto_der_decode_int(&seq, &seq_length, extract_mpi,
 140                                &rsa->e, errp) < 0 ||
 141         qcrypto_der_decode_int(&seq, &seq_length, extract_mpi,
 142                                &rsa->d, errp) < 0 ||
 143         qcrypto_der_decode_int(&seq, &seq_length, extract_mpi, &rsa->p,
 144                                errp) < 0 ||
 145         qcrypto_der_decode_int(&seq, &seq_length, extract_mpi, &rsa->q,
 146                                errp) < 0 ||
 147         qcrypto_der_decode_int(&seq, &seq_length, extract_mpi, &rsa->dp,
 148                                errp) < 0 ||
 149         qcrypto_der_decode_int(&seq, &seq_length, extract_mpi, &rsa->dq,
 150                                errp) < 0 ||
 151         qcrypto_der_decode_int(&seq, &seq_length, extract_mpi, &rsa->u,
 152                                errp) < 0) {
 153         goto error;
 154     }
 155
 156     /**
 157      * According to the standard, otherPrimeInfos must be present for version 1.
 158      * There is no strict verification here, this is to be compatible with
 159      * the unit test of the kernel. TODO: remove this until linux kernel's
 160      * unit-test is fixed.
 161      */
 162     if (version == 1 && seq_length != 0) {
 163         if (qcrypto_der_decode_seq(&seq, &seq_length, NULL, NULL, errp) < 0) {
 164             goto error;
 165         }
 166         if (seq_length != 0) {
 167             goto error;
 168         }
 169         return rsa;
 170     }
 171     if (seq_length != 0) {
 172         goto error;
 173     }
 174
 175     return rsa;
 176
 177 error:
 178     if (errp && !*errp) {
 179         error_setg(errp, "Invalid RSA private key");
 180     }
 181     qcrypto_akcipher_rsakey_free(rsa);
 182     return NULL;
 183 }
 184
 185 QCryptoAkCipherRSAKey *qcrypto_akcipher_rsakey_parse(
 186     QCryptoAkCipherKeyType type, const uint8_t *key,
 187     size_t keylen, Error **errp)
 188 {
 189     switch (type) {
 190     case QCRYPTO_AKCIPHER_KEY_TYPE_PRIVATE:
 191         return qcrypto_builtin_rsa_private_key_parse(key, keylen, errp);
 192
 193     case QCRYPTO_AKCIPHER_KEY_TYPE_PUBLIC:
 194         return qcrypto_builtin_rsa_public_key_parse(key, keylen, errp);
 195
 196     default:
 197         error_setg(errp, "Unknown key type: %d", type);
 198         return NULL;
 199     }
 200 }