Annotation of embedaddon/strongswan/src/libstrongswan/plugins/gcrypt/gcrypt_rsa_public_key.c, revision 1.1
1.1 ! misho 1: /*
! 2: * Copyright (C) 2017 Tobias Brunner
! 3: * Copyright (C) 2005-2009 Martin Willi
! 4: * HSR Hochschule fuer Technik Rapperswil
! 5: *
! 6: * This program is free software; you can redistribute it and/or modify it
! 7: * under the terms of the GNU General Public License as published by the
! 8: * Free Software Foundation; either version 2 of the License, or (at your
! 9: * option) any later version. See <http://www.fsf.org/copyleft/gpl.txt>.
! 10: *
! 11: * This program is distributed in the hope that it will be useful, but
! 12: * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
! 13: * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
! 14: * for more details.
! 15: */
! 16:
! 17: #include <gcrypt.h>
! 18:
! 19: #include "gcrypt_rsa_public_key.h"
! 20:
! 21: #include <utils/debug.h>
! 22: #include <asn1/oid.h>
! 23: #include <asn1/asn1.h>
! 24: #include <asn1/asn1_parser.h>
! 25: #include <crypto/hashers/hasher.h>
! 26: #include <credentials/keys/signature_params.h>
! 27:
! 28: typedef struct private_gcrypt_rsa_public_key_t private_gcrypt_rsa_public_key_t;
! 29:
! 30: /**
! 31: * Private data structure with signing context.
! 32: */
! 33: struct private_gcrypt_rsa_public_key_t {
! 34:
! 35: /**
! 36: * Public interface for this signer.
! 37: */
! 38: gcrypt_rsa_public_key_t public;
! 39:
! 40: /**
! 41: * gcrypt S-expression representing an public RSA key
! 42: */
! 43: gcry_sexp_t key;
! 44:
! 45: /**
! 46: * reference counter
! 47: */
! 48: refcount_t ref;
! 49: };
! 50:
! 51: /**
! 52: * Implemented in gcrypt_rsa_private_key.c
! 53: */
! 54: chunk_t gcrypt_rsa_find_token(gcry_sexp_t sexp, char *name, gcry_sexp_t key);
! 55:
! 56: /**
! 57: * verification of a padded PKCS1 signature without an OID
! 58: */
! 59: static bool verify_raw(private_gcrypt_rsa_public_key_t *this,
! 60: chunk_t data, chunk_t signature)
! 61: {
! 62: gcry_sexp_t in, sig;
! 63: gcry_error_t err;
! 64: chunk_t em;
! 65: size_t k;
! 66:
! 67: /* EM = 0x00 || 0x01 || PS || 0x00 || T
! 68: * PS = 0xFF padding, with length to fill em
! 69: * T = data
! 70: */
! 71: k = gcry_pk_get_nbits(this->key) / 8;
! 72: if (data.len > k - 3)
! 73: {
! 74: return FALSE;
! 75: }
! 76: em = chunk_alloc(k);
! 77: memset(em.ptr, 0xFF, em.len);
! 78: em.ptr[0] = 0x00;
! 79: em.ptr[1] = 0x01;
! 80: em.ptr[em.len - data.len - 1] = 0x00;
! 81: memcpy(em.ptr + em.len - data.len, data.ptr, data.len);
! 82:
! 83: err = gcry_sexp_build(&in, NULL, "(data(flags raw)(value %b))",
! 84: em.len, em.ptr);
! 85: chunk_free(&em);
! 86: if (err)
! 87: {
! 88: DBG1(DBG_LIB, "building data S-expression failed: %s",
! 89: gpg_strerror(err));
! 90: return FALSE;
! 91: }
! 92: err = gcry_sexp_build(&sig, NULL, "(sig-val(rsa(s %b)))",
! 93: signature.len, signature.ptr);
! 94: if (err)
! 95: {
! 96: DBG1(DBG_LIB, "building signature S-expression failed: %s",
! 97: gpg_strerror(err));
! 98: gcry_sexp_release(in);
! 99: return FALSE;
! 100: }
! 101: err = gcry_pk_verify(sig, in, this->key);
! 102: gcry_sexp_release(in);
! 103: gcry_sexp_release(sig);
! 104: if (err)
! 105: {
! 106: DBG1(DBG_LIB, "RSA signature verification failed: %s",
! 107: gpg_strerror(err));
! 108: return FALSE;
! 109: }
! 110: return TRUE;
! 111: }
! 112:
! 113: /**
! 114: * Verification of an EMSA PKCS1v1.5 / EMSA-PSS signature described in PKCS#1
! 115: */
! 116: static bool verify_pkcs1(private_gcrypt_rsa_public_key_t *this,
! 117: hash_algorithm_t algorithm, rsa_pss_params_t *pss,
! 118: chunk_t data, chunk_t signature)
! 119: {
! 120: hasher_t *hasher;
! 121: chunk_t hash;
! 122: gcry_error_t err;
! 123: gcry_sexp_t in, sig;
! 124: char *hash_name = enum_to_name(hash_algorithm_short_names, algorithm);
! 125:
! 126: hasher = lib->crypto->create_hasher(lib->crypto, algorithm);
! 127: if (!hasher)
! 128: {
! 129: DBG1(DBG_LIB, "hash algorithm %N not supported",
! 130: hash_algorithm_names, algorithm);
! 131: return FALSE;
! 132: }
! 133: if (!hasher->allocate_hash(hasher, data, &hash))
! 134: {
! 135: hasher->destroy(hasher);
! 136: return FALSE;
! 137: }
! 138: hasher->destroy(hasher);
! 139:
! 140: if (pss)
! 141: {
! 142: u_int slen = pss->salt_len;
! 143: err = gcry_sexp_build(&in, NULL,
! 144: "(data(flags pss)(salt-length %u)(hash %s %b))",
! 145: slen, hash_name, hash.len, hash.ptr);
! 146: }
! 147: else
! 148: {
! 149: err = gcry_sexp_build(&in, NULL, "(data(flags pkcs1)(hash %s %b))",
! 150: hash_name, hash.len, hash.ptr);
! 151: }
! 152: chunk_free(&hash);
! 153: if (err)
! 154: {
! 155: DBG1(DBG_LIB, "building data S-expression failed: %s",
! 156: gpg_strerror(err));
! 157: return FALSE;
! 158: }
! 159:
! 160: err = gcry_sexp_build(&sig, NULL, "(sig-val(rsa(s %b)))",
! 161: signature.len, signature.ptr);
! 162: if (err)
! 163: {
! 164: DBG1(DBG_LIB, "building signature S-expression failed: %s",
! 165: gpg_strerror(err));
! 166: gcry_sexp_release(in);
! 167: return FALSE;
! 168: }
! 169: err = gcry_pk_verify(sig, in, this->key);
! 170: gcry_sexp_release(in);
! 171: gcry_sexp_release(sig);
! 172: if (err)
! 173: {
! 174: DBG1(DBG_LIB, "RSA signature verification failed: %s",
! 175: gpg_strerror(err));
! 176: return FALSE;
! 177: }
! 178: return TRUE;
! 179: }
! 180:
! 181: #if GCRYPT_VERSION_NUMBER >= 0x010700
! 182: /**
! 183: * Verification of an EMSA-PSS signature described in PKCS#1
! 184: */
! 185: static bool verify_pss(private_gcrypt_rsa_public_key_t *this,
! 186: rsa_pss_params_t *params, chunk_t data, chunk_t sig)
! 187: {
! 188: if (!params)
! 189: {
! 190: return FALSE;
! 191: }
! 192: if (params->mgf1_hash != params->hash)
! 193: {
! 194: DBG1(DBG_LIB, "unable to use a different MGF1 hash for RSA-PSS");
! 195: return FALSE;
! 196: }
! 197: return verify_pkcs1(this, params->hash, params, data, sig);
! 198: }
! 199: #endif
! 200:
! 201: METHOD(public_key_t, get_type, key_type_t,
! 202: private_gcrypt_rsa_public_key_t *this)
! 203: {
! 204: return KEY_RSA;
! 205: }
! 206:
! 207: METHOD(public_key_t, verify, bool,
! 208: private_gcrypt_rsa_public_key_t *this, signature_scheme_t scheme,
! 209: void *params, chunk_t data, chunk_t signature)
! 210: {
! 211: switch (scheme)
! 212: {
! 213: case SIGN_RSA_EMSA_PKCS1_NULL:
! 214: return verify_raw(this, data, signature);
! 215: case SIGN_RSA_EMSA_PKCS1_SHA2_224:
! 216: return verify_pkcs1(this, HASH_SHA224, NULL, data, signature);
! 217: case SIGN_RSA_EMSA_PKCS1_SHA2_256:
! 218: return verify_pkcs1(this, HASH_SHA256, NULL, data, signature);
! 219: case SIGN_RSA_EMSA_PKCS1_SHA2_384:
! 220: return verify_pkcs1(this, HASH_SHA384, NULL, data, signature);
! 221: case SIGN_RSA_EMSA_PKCS1_SHA2_512:
! 222: return verify_pkcs1(this, HASH_SHA512, NULL, data, signature);
! 223: case SIGN_RSA_EMSA_PKCS1_SHA1:
! 224: return verify_pkcs1(this, HASH_SHA1, NULL, data, signature);
! 225: case SIGN_RSA_EMSA_PKCS1_MD5:
! 226: return verify_pkcs1(this, HASH_MD5, NULL, data, signature);
! 227: #if GCRYPT_VERSION_NUMBER >= 0x010700
! 228: case SIGN_RSA_EMSA_PSS:
! 229: return verify_pss(this, params, data, signature);
! 230: #endif
! 231: default:
! 232: DBG1(DBG_LIB, "signature scheme %N not supported in RSA",
! 233: signature_scheme_names, scheme);
! 234: return FALSE;
! 235: }
! 236: }
! 237:
! 238: METHOD(public_key_t, encrypt_, bool,
! 239: private_gcrypt_rsa_public_key_t *this, encryption_scheme_t scheme,
! 240: chunk_t plain, chunk_t *encrypted)
! 241: {
! 242: gcry_sexp_t in, out;
! 243: gcry_error_t err;
! 244:
! 245: if (scheme != ENCRYPT_RSA_PKCS1)
! 246: {
! 247: DBG1(DBG_LIB, "encryption scheme %N not supported",
! 248: encryption_scheme_names, scheme);
! 249: return FALSE;
! 250: }
! 251: /* "pkcs1" uses PKCS 1.5 (section 8.1) block type 2 encryption:
! 252: * 00 | 02 | RANDOM | 00 | DATA */
! 253: err = gcry_sexp_build(&in, NULL, "(data(flags pkcs1)(value %b))",
! 254: plain.len, plain.ptr);
! 255: if (err)
! 256: {
! 257: DBG1(DBG_LIB, "building encryption S-expression failed: %s",
! 258: gpg_strerror(err));
! 259: return FALSE;
! 260: }
! 261: err = gcry_pk_encrypt(&out, in, this->key);
! 262: gcry_sexp_release(in);
! 263: if (err)
! 264: {
! 265: DBG1(DBG_LIB, "encrypting data using pkcs1 failed: %s",
! 266: gpg_strerror(err));
! 267: return FALSE;
! 268: }
! 269: *encrypted = gcrypt_rsa_find_token(out, "a", this->key);
! 270: gcry_sexp_release(out);
! 271: return !!encrypted->len;
! 272: }
! 273:
! 274: METHOD(public_key_t, get_keysize, int,
! 275: private_gcrypt_rsa_public_key_t *this)
! 276: {
! 277: return gcry_pk_get_nbits(this->key);
! 278: }
! 279:
! 280: METHOD(public_key_t, get_encoding, bool,
! 281: private_gcrypt_rsa_public_key_t *this, cred_encoding_type_t type,
! 282: chunk_t *encoding)
! 283: {
! 284: chunk_t n, e;
! 285: bool success;
! 286:
! 287: n = gcrypt_rsa_find_token(this->key, "n", NULL);
! 288: e = gcrypt_rsa_find_token(this->key, "e", NULL);
! 289: success = lib->encoding->encode(lib->encoding, type, NULL, encoding,
! 290: CRED_PART_RSA_MODULUS, n, CRED_PART_RSA_PUB_EXP, e,
! 291: CRED_PART_END);
! 292: chunk_free(&n);
! 293: chunk_free(&e);
! 294:
! 295: return success;
! 296: }
! 297:
! 298: METHOD(public_key_t, get_fingerprint, bool,
! 299: private_gcrypt_rsa_public_key_t *this, cred_encoding_type_t type,
! 300: chunk_t *fp)
! 301: {
! 302: chunk_t n, e;
! 303: bool success;
! 304:
! 305: if (lib->encoding->get_cache(lib->encoding, type, this, fp))
! 306: {
! 307: return TRUE;
! 308: }
! 309: n = gcrypt_rsa_find_token(this->key, "n", NULL);
! 310: e = gcrypt_rsa_find_token(this->key, "e", NULL);
! 311:
! 312: success = lib->encoding->encode(lib->encoding,
! 313: type, this, fp, CRED_PART_RSA_MODULUS, n,
! 314: CRED_PART_RSA_PUB_EXP, e, CRED_PART_END);
! 315: chunk_free(&n);
! 316: chunk_free(&e);
! 317: return success;
! 318: }
! 319:
! 320: METHOD(public_key_t, get_ref, public_key_t*,
! 321: private_gcrypt_rsa_public_key_t *this)
! 322: {
! 323: ref_get(&this->ref);
! 324: return &this->public.key;
! 325: }
! 326:
! 327: METHOD(public_key_t, destroy, void,
! 328: private_gcrypt_rsa_public_key_t *this)
! 329: {
! 330: if (ref_put(&this->ref))
! 331: {
! 332: gcry_sexp_release(this->key);
! 333: lib->encoding->clear_cache(lib->encoding, this);
! 334: free(this);
! 335: }
! 336: }
! 337:
! 338: /**
! 339: * See header.
! 340: */
! 341: gcrypt_rsa_public_key_t *gcrypt_rsa_public_key_load(key_type_t type,
! 342: va_list args)
! 343: {
! 344: private_gcrypt_rsa_public_key_t *this;
! 345: gcry_error_t err;
! 346: chunk_t n, e;
! 347:
! 348: n = e = chunk_empty;
! 349: while (TRUE)
! 350: {
! 351: switch (va_arg(args, builder_part_t))
! 352: {
! 353: case BUILD_RSA_MODULUS:
! 354: n = va_arg(args, chunk_t);
! 355: continue;
! 356: case BUILD_RSA_PUB_EXP:
! 357: e = va_arg(args, chunk_t);
! 358: continue;
! 359: case BUILD_END:
! 360: break;
! 361: default:
! 362: return NULL;
! 363: }
! 364: break;
! 365: }
! 366:
! 367: INIT(this,
! 368: .public = {
! 369: .key = {
! 370: .get_type = _get_type,
! 371: .verify = _verify,
! 372: .encrypt = _encrypt_,
! 373: .equals = public_key_equals,
! 374: .get_keysize = _get_keysize,
! 375: .get_fingerprint = _get_fingerprint,
! 376: .has_fingerprint = public_key_has_fingerprint,
! 377: .get_encoding = _get_encoding,
! 378: .get_ref = _get_ref,
! 379: .destroy = _destroy,
! 380: },
! 381: },
! 382: .ref = 1,
! 383: );
! 384:
! 385: err = gcry_sexp_build(&this->key, NULL, "(public-key(rsa(n %b)(e %b)))",
! 386: n.len, n.ptr, e.len, e.ptr);
! 387: if (err)
! 388: {
! 389: DBG1(DBG_LIB, "loading public key failed: %s", gpg_strerror(err));
! 390: free(this);
! 391: return NULL;
! 392: }
! 393:
! 394: return &this->public;
! 395: }
! 396:
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to gcrypt_rsa_public_key.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / strongswan / src / libstrongswan / plugins / gcrypt