diff options
Diffstat (limited to 'libnm-core/nm-crypto-nss.c')
| -rw-r--r-- | libnm-core/nm-crypto-nss.c | 913 |
1 files changed, 467 insertions, 446 deletions
diff --git a/libnm-core/nm-crypto-nss.c b/libnm-core/nm-crypto-nss.c index 5dbbef00..ef9c5620 100644 --- a/libnm-core/nm-crypto-nss.c +++ b/libnm-core/nm-crypto-nss.c @@ -1,4 +1,4 @@ -// SPDX-License-Identifier: LGPL-2.1+ +/* SPDX-License-Identifier: LGPL-2.1+ */ /* * Dan Williams <dcbw@redhat.com> * Copyright (C) 2007 - 2009 Red Hat, Inc. @@ -8,7 +8,7 @@ #include "nm-crypto-impl.h" -NM_PRAGMA_WARNING_DISABLE ("-Wstrict-prototypes") +NM_PRAGMA_WARNING_DISABLE("-Wstrict-prototypes") #include <prinit.h> #include <nss.h> #include <pk11pub.h> @@ -26,502 +26,523 @@ NM_PRAGMA_WARNING_REENABLE /*****************************************************************************/ static gboolean -_get_cipher_info (NMCryptoCipherType cipher, - CK_MECHANISM_TYPE *out_cipher_mech, - guint8 *out_real_iv_len) +_get_cipher_info(NMCryptoCipherType cipher, + CK_MECHANISM_TYPE *out_cipher_mech, + guint8 * out_real_iv_len) { - static const CK_MECHANISM_TYPE cipher_mechs[] = { - [NM_CRYPTO_CIPHER_DES_EDE3_CBC] = CKM_DES3_CBC_PAD, - [NM_CRYPTO_CIPHER_DES_CBC] = CKM_DES_CBC_PAD, - [NM_CRYPTO_CIPHER_AES_128_CBC] = CKM_AES_CBC_PAD, - [NM_CRYPTO_CIPHER_AES_192_CBC] = CKM_AES_CBC_PAD, - [NM_CRYPTO_CIPHER_AES_256_CBC] = CKM_AES_CBC_PAD, - }; - - g_return_val_if_fail (_NM_INT_NOT_NEGATIVE (cipher) && (gsize) cipher < G_N_ELEMENTS (cipher_mechs), FALSE); - - if (!cipher_mechs[cipher]) - return FALSE; - - NM_SET_OUT (out_cipher_mech, cipher_mechs[cipher]); - NM_SET_OUT (out_real_iv_len, nm_crypto_cipher_get_info (cipher)->real_iv_len); - return TRUE; + static const CK_MECHANISM_TYPE cipher_mechs[] = { + [NM_CRYPTO_CIPHER_DES_EDE3_CBC] = CKM_DES3_CBC_PAD, + [NM_CRYPTO_CIPHER_DES_CBC] = CKM_DES_CBC_PAD, + [NM_CRYPTO_CIPHER_AES_128_CBC] = CKM_AES_CBC_PAD, + [NM_CRYPTO_CIPHER_AES_192_CBC] = CKM_AES_CBC_PAD, + [NM_CRYPTO_CIPHER_AES_256_CBC] = CKM_AES_CBC_PAD, + }; + + g_return_val_if_fail(_NM_INT_NOT_NEGATIVE(cipher) + && (gsize) cipher < G_N_ELEMENTS(cipher_mechs), + FALSE); + + if (!cipher_mechs[cipher]) + return FALSE; + + NM_SET_OUT(out_cipher_mech, cipher_mechs[cipher]); + NM_SET_OUT(out_real_iv_len, nm_crypto_cipher_get_info(cipher)->real_iv_len); + return TRUE; } /*****************************************************************************/ gboolean -_nm_crypto_init (GError **error) +_nm_crypto_init(GError **error) { - static gboolean initialized = FALSE; - SECStatus ret; - - if (initialized) - return TRUE; - - PR_Init (PR_USER_THREAD, PR_PRIORITY_NORMAL, 1); - ret = NSS_NoDB_Init (NULL); - if (ret != SECSuccess) { - g_set_error (error, NM_CRYPTO_ERROR, - NM_CRYPTO_ERROR_FAILED, - _("Failed to initialize the crypto engine: %d."), - PR_GetError ()); - PR_Cleanup (); - return FALSE; - } - - SEC_PKCS12EnableCipher (PKCS12_RC4_40, 1); - SEC_PKCS12EnableCipher (PKCS12_RC4_128, 1); - SEC_PKCS12EnableCipher (PKCS12_RC2_CBC_40, 1); - SEC_PKCS12EnableCipher (PKCS12_RC2_CBC_128, 1); - SEC_PKCS12EnableCipher (PKCS12_DES_56, 1); - SEC_PKCS12EnableCipher (PKCS12_DES_EDE3_168, 1); - SEC_PKCS12SetPreferredCipher (PKCS12_DES_EDE3_168, 1); - - initialized = TRUE; - return TRUE; + static gboolean initialized = FALSE; + SECStatus ret; + + if (initialized) + return TRUE; + + PR_Init(PR_USER_THREAD, PR_PRIORITY_NORMAL, 1); + ret = NSS_NoDB_Init(NULL); + if (ret != SECSuccess) { + g_set_error(error, + NM_CRYPTO_ERROR, + NM_CRYPTO_ERROR_FAILED, + _("Failed to initialize the crypto engine: %d."), + PR_GetError()); + PR_Cleanup(); + return FALSE; + } + + SEC_PKCS12EnableCipher(PKCS12_RC4_40, 1); + SEC_PKCS12EnableCipher(PKCS12_RC4_128, 1); + SEC_PKCS12EnableCipher(PKCS12_RC2_CBC_40, 1); + SEC_PKCS12EnableCipher(PKCS12_RC2_CBC_128, 1); + SEC_PKCS12EnableCipher(PKCS12_DES_56, 1); + SEC_PKCS12EnableCipher(PKCS12_DES_EDE3_168, 1); + SEC_PKCS12SetPreferredCipher(PKCS12_DES_EDE3_168, 1); + + initialized = TRUE; + return TRUE; } guint8 * -_nmtst_crypto_decrypt (NMCryptoCipherType cipher, - const guint8 *data, - gsize data_len, - const guint8 *iv, - gsize iv_len, - const guint8 *key, - gsize key_len, - gsize *out_len, - GError **error) +_nmtst_crypto_decrypt(NMCryptoCipherType cipher, + const guint8 * data, + gsize data_len, + const guint8 * iv, + gsize iv_len, + const guint8 * key, + gsize key_len, + gsize * out_len, + GError ** error) { - CK_MECHANISM_TYPE cipher_mech; - PK11SlotInfo *slot = NULL; - SECItem key_item; - PK11SymKey *sym_key = NULL; - SECItem *sec_param = NULL; - PK11Context *ctx = NULL; - nm_auto_clear_secret_ptr NMSecretPtr output = { 0 }; - SECStatus s; - gboolean success = FALSE; - int decrypted_len = 0; - unsigned extra = 0; - unsigned pad_len = 0; - guint32 i; - guint8 real_iv_len; - - if (!_get_cipher_info (cipher, &cipher_mech, &real_iv_len)) { - g_set_error (error, NM_CRYPTO_ERROR, - NM_CRYPTO_ERROR_UNKNOWN_CIPHER, - _("Unsupported key cipher for decryption")); - return NULL; - } - - if (iv_len < real_iv_len) { - g_set_error (error, NM_CRYPTO_ERROR, - NM_CRYPTO_ERROR_INVALID_DATA, - _("Invalid IV length (must be at least %u)."), - (guint) real_iv_len); - return NULL; - } - - if (!_nm_crypto_init (error)) - return NULL; - - slot = PK11_GetBestSlot (cipher_mech, NULL); - if (!slot) { - g_set_error (error, NM_CRYPTO_ERROR, - NM_CRYPTO_ERROR_FAILED, - _("Failed to initialize the decryption cipher slot.")); - goto out; - } - - key_item.data = (unsigned char *) key; - key_item.len = key_len; - sym_key = PK11_ImportSymKey (slot, cipher_mech, PK11_OriginUnwrap, CKA_DECRYPT, &key_item, NULL); - if (!sym_key) { - g_set_error (error, NM_CRYPTO_ERROR, - NM_CRYPTO_ERROR_DECRYPTION_FAILED, - _("Failed to set symmetric key for decryption.")); - goto out; - } - - key_item.data = (unsigned char *) iv; - key_item.len = real_iv_len; - sec_param = PK11_ParamFromIV (cipher_mech, &key_item); - if (!sec_param) { - g_set_error (error, NM_CRYPTO_ERROR, - NM_CRYPTO_ERROR_DECRYPTION_FAILED, - _("Failed to set IV for decryption.")); - goto out; - } - - ctx = PK11_CreateContextBySymKey (cipher_mech, CKA_DECRYPT, sym_key, sec_param); - if (!ctx) { - g_set_error (error, NM_CRYPTO_ERROR, - NM_CRYPTO_ERROR_DECRYPTION_FAILED, - _("Failed to initialize the decryption context.")); - goto out; - } - - output.len = data_len; - output.bin = g_malloc (data_len); - - s = PK11_CipherOp (ctx, - (unsigned char *) output.bin, - &decrypted_len, - output.len, - data, - data_len); - if (s != SECSuccess) { - g_set_error (error, NM_CRYPTO_ERROR, - NM_CRYPTO_ERROR_DECRYPTION_FAILED, - _("Failed to decrypt the private key: %d."), - PORT_GetError ()); - goto out; - } - - if (decrypted_len > data_len) { - g_set_error (error, NM_CRYPTO_ERROR, - NM_CRYPTO_ERROR_DECRYPTION_FAILED, - _("Failed to decrypt the private key: decrypted data too large.")); - goto out; - } - - s = PK11_DigestFinal (ctx, - (unsigned char *) &output.bin[decrypted_len], - &extra, - data_len - decrypted_len); - if (s != SECSuccess) { - g_set_error (error, NM_CRYPTO_ERROR, - NM_CRYPTO_ERROR_DECRYPTION_FAILED, - _("Failed to finalize decryption of the private key: %d."), - PORT_GetError ()); - goto out; - } - - decrypted_len += extra; - pad_len = data_len - decrypted_len; - - /* Check if the padding at the end of the decrypted data is valid */ - if (pad_len == 0 || pad_len > real_iv_len) { - g_set_error (error, NM_CRYPTO_ERROR, - NM_CRYPTO_ERROR_DECRYPTION_FAILED, - _("Failed to decrypt the private key: unexpected padding length.")); - goto out; - } - - /* Validate tail padding; last byte is the padding size, and all pad bytes - * should contain the padding size. - */ - for (i = pad_len; i > 0; i--) { - if (output.bin[data_len - i] != pad_len) { - g_set_error (error, NM_CRYPTO_ERROR, - NM_CRYPTO_ERROR_DECRYPTION_FAILED, - _("Failed to decrypt the private key.")); - goto out; - } - } - - success = TRUE; + CK_MECHANISM_TYPE cipher_mech; + PK11SlotInfo * slot = NULL; + SECItem key_item; + PK11SymKey * sym_key = NULL; + SECItem * sec_param = NULL; + PK11Context * ctx = NULL; + nm_auto_clear_secret_ptr NMSecretPtr output = {0}; + SECStatus s; + gboolean success = FALSE; + int decrypted_len = 0; + unsigned extra = 0; + unsigned pad_len = 0; + guint32 i; + guint8 real_iv_len; + + if (!_get_cipher_info(cipher, &cipher_mech, &real_iv_len)) { + g_set_error(error, + NM_CRYPTO_ERROR, + NM_CRYPTO_ERROR_UNKNOWN_CIPHER, + _("Unsupported key cipher for decryption")); + return NULL; + } + + if (iv_len < real_iv_len) { + g_set_error(error, + NM_CRYPTO_ERROR, + NM_CRYPTO_ERROR_INVALID_DATA, + _("Invalid IV length (must be at least %u)."), + (guint) real_iv_len); + return NULL; + } + + if (!_nm_crypto_init(error)) + return NULL; + + slot = PK11_GetBestSlot(cipher_mech, NULL); + if (!slot) { + g_set_error(error, + NM_CRYPTO_ERROR, + NM_CRYPTO_ERROR_FAILED, + _("Failed to initialize the decryption cipher slot.")); + goto out; + } + + key_item.data = (unsigned char *) key; + key_item.len = key_len; + sym_key = PK11_ImportSymKey(slot, cipher_mech, PK11_OriginUnwrap, CKA_DECRYPT, &key_item, NULL); + if (!sym_key) { + g_set_error(error, + NM_CRYPTO_ERROR, + NM_CRYPTO_ERROR_DECRYPTION_FAILED, + _("Failed to set symmetric key for decryption.")); + goto out; + } + + key_item.data = (unsigned char *) iv; + key_item.len = real_iv_len; + sec_param = PK11_ParamFromIV(cipher_mech, &key_item); + if (!sec_param) { + g_set_error(error, + NM_CRYPTO_ERROR, + NM_CRYPTO_ERROR_DECRYPTION_FAILED, + _("Failed to set IV for decryption.")); + goto out; + } + + ctx = PK11_CreateContextBySymKey(cipher_mech, CKA_DECRYPT, sym_key, sec_param); + if (!ctx) { + g_set_error(error, + NM_CRYPTO_ERROR, + NM_CRYPTO_ERROR_DECRYPTION_FAILED, + _("Failed to initialize the decryption context.")); + goto out; + } + + output.len = data_len; + output.bin = g_malloc(data_len); + + s = PK11_CipherOp(ctx, + (unsigned char *) output.bin, + &decrypted_len, + output.len, + data, + data_len); + if (s != SECSuccess) { + g_set_error(error, + NM_CRYPTO_ERROR, + NM_CRYPTO_ERROR_DECRYPTION_FAILED, + _("Failed to decrypt the private key: %d."), + PORT_GetError()); + goto out; + } + + if (decrypted_len > data_len) { + g_set_error(error, + NM_CRYPTO_ERROR, + NM_CRYPTO_ERROR_DECRYPTION_FAILED, + _("Failed to decrypt the private key: decrypted data too large.")); + goto out; + } + + s = PK11_DigestFinal(ctx, + (unsigned char *) &output.bin[decrypted_len], + &extra, + data_len - decrypted_len); + if (s != SECSuccess) { + g_set_error(error, + NM_CRYPTO_ERROR, + NM_CRYPTO_ERROR_DECRYPTION_FAILED, + _("Failed to finalize decryption of the private key: %d."), + PORT_GetError()); + goto out; + } + + decrypted_len += extra; + pad_len = data_len - decrypted_len; + + /* Check if the padding at the end of the decrypted data is valid */ + if (pad_len == 0 || pad_len > real_iv_len) { + g_set_error(error, + NM_CRYPTO_ERROR, + NM_CRYPTO_ERROR_DECRYPTION_FAILED, + _("Failed to decrypt the private key: unexpected padding length.")); + goto out; + } + + /* Validate tail padding; last byte is the padding size, and all pad bytes + * should contain the padding size. + */ + for (i = pad_len; i > 0; i--) { + if (output.bin[data_len - i] != pad_len) { + g_set_error(error, + NM_CRYPTO_ERROR, + NM_CRYPTO_ERROR_DECRYPTION_FAILED, + _("Failed to decrypt the private key.")); + goto out; + } + } + + success = TRUE; out: - if (ctx) - PK11_DestroyContext (ctx, PR_TRUE); - if (sym_key) - PK11_FreeSymKey (sym_key); - if (sec_param) - SECITEM_FreeItem (sec_param, PR_TRUE); - if (slot) - PK11_FreeSlot (slot); - - if (!success) - return NULL; - - if (decrypted_len < output.len) - nm_explicit_bzero (&output.bin[decrypted_len], output.len - decrypted_len); - *out_len = decrypted_len; - return g_steal_pointer (&output.bin); + if (ctx) + PK11_DestroyContext(ctx, PR_TRUE); + if (sym_key) + PK11_FreeSymKey(sym_key); + if (sec_param) + SECITEM_FreeItem(sec_param, PR_TRUE); + if (slot) + PK11_FreeSlot(slot); + + if (!success) + return NULL; + + if (decrypted_len < output.len) + nm_explicit_bzero(&output.bin[decrypted_len], output.len - decrypted_len); + *out_len = decrypted_len; + return g_steal_pointer(&output.bin); } guint8 * -_nmtst_crypto_encrypt (NMCryptoCipherType cipher, - const guint8 *data, - gsize data_len, - const guint8 *iv, - gsize iv_len, - const guint8 *key, - gsize key_len, - gsize *out_len, - GError **error) +_nmtst_crypto_encrypt(NMCryptoCipherType cipher, + const guint8 * data, + gsize data_len, + const guint8 * iv, + gsize iv_len, + const guint8 * key, + gsize key_len, + gsize * out_len, + GError ** error) { - SECStatus ret; - CK_MECHANISM_TYPE cipher_mech = CKM_DES3_CBC_PAD; - PK11SlotInfo *slot = NULL; - SECItem key_item = { .data = (unsigned char *) key, .len = key_len }; - SECItem iv_item = { .data = (unsigned char *) iv, .len = iv_len }; - PK11SymKey *sym_key = NULL; - SECItem *sec_param = NULL; - PK11Context *ctx = NULL; - nm_auto_clear_secret_ptr NMSecretPtr padded_buf = { 0 }; - nm_auto_clear_secret_ptr NMSecretPtr output = { 0 }; - int encrypted_len = 0, i; - gboolean success = FALSE; - gsize pad_len; - - if ( cipher == NM_CRYPTO_CIPHER_DES_CBC - || !_get_cipher_info (cipher, &cipher_mech, NULL)) { - g_set_error (error, NM_CRYPTO_ERROR, - NM_CRYPTO_ERROR_UNKNOWN_CIPHER, - _("Unsupported key cipher for encryption")); - return NULL; - } - - if (!_nm_crypto_init (error)) - return NULL; - - slot = PK11_GetBestSlot (cipher_mech, NULL); - if (!slot) { - g_set_error (error, NM_CRYPTO_ERROR, - NM_CRYPTO_ERROR_FAILED, - _("Failed to initialize the encryption cipher slot.")); - return NULL; - } - - sym_key = PK11_ImportSymKey (slot, cipher_mech, PK11_OriginUnwrap, CKA_ENCRYPT, &key_item, NULL); - if (!sym_key) { - g_set_error (error, NM_CRYPTO_ERROR, - NM_CRYPTO_ERROR_ENCRYPTION_FAILED, - _("Failed to set symmetric key for encryption.")); - goto out; - } - - sec_param = PK11_ParamFromIV (cipher_mech, &iv_item); - if (!sec_param) { - g_set_error (error, NM_CRYPTO_ERROR, - NM_CRYPTO_ERROR_ENCRYPTION_FAILED, - _("Failed to set IV for encryption.")); - goto out; - } - - ctx = PK11_CreateContextBySymKey (cipher_mech, CKA_ENCRYPT, sym_key, sec_param); - if (!ctx) { - g_set_error (error, NM_CRYPTO_ERROR, - NM_CRYPTO_ERROR_ENCRYPTION_FAILED, - _("Failed to initialize the encryption context.")); - goto out; - } - - /* If data->len % ivlen == 0, then we add another complete block - * onto the end so that the decrypter knows there's padding. - */ - pad_len = iv_len - (data_len % iv_len); - - padded_buf.len = data_len + pad_len; - padded_buf.bin = g_malloc (padded_buf.len); - - memcpy (padded_buf.bin, data, data_len); - for (i = 0; i < pad_len; i++) - padded_buf.bin[data_len + i] = (guint8) (pad_len & 0xFF); - - output.len = padded_buf.len; - output.bin = g_malloc (output.len); - - ret = PK11_CipherOp (ctx, output.bin, &encrypted_len, output.len, padded_buf.bin, padded_buf.len); - if (ret != SECSuccess) { - g_set_error (error, NM_CRYPTO_ERROR, - NM_CRYPTO_ERROR_ENCRYPTION_FAILED, - _("Failed to encrypt: %d."), - PORT_GetError ()); - goto out; - } - - if (encrypted_len != output.len) { - g_set_error (error, NM_CRYPTO_ERROR, - NM_CRYPTO_ERROR_ENCRYPTION_FAILED, - _("Unexpected amount of data after encrypting.")); - goto out; - } - - success = TRUE; + SECStatus ret; + CK_MECHANISM_TYPE cipher_mech = CKM_DES3_CBC_PAD; + PK11SlotInfo * slot = NULL; + SECItem key_item = {.data = (unsigned char *) key, .len = key_len}; + SECItem iv_item = {.data = (unsigned char *) iv, .len = iv_len}; + PK11SymKey * sym_key = NULL; + SECItem * sec_param = NULL; + PK11Context * ctx = NULL; + nm_auto_clear_secret_ptr NMSecretPtr padded_buf = {0}; + nm_auto_clear_secret_ptr NMSecretPtr output = {0}; + int encrypted_len = 0, i; + gboolean success = FALSE; + gsize pad_len; + + if (cipher == NM_CRYPTO_CIPHER_DES_CBC || !_get_cipher_info(cipher, &cipher_mech, NULL)) { + g_set_error(error, + NM_CRYPTO_ERROR, + NM_CRYPTO_ERROR_UNKNOWN_CIPHER, + _("Unsupported key cipher for encryption")); + return NULL; + } + + if (!_nm_crypto_init(error)) + return NULL; + + slot = PK11_GetBestSlot(cipher_mech, NULL); + if (!slot) { + g_set_error(error, + NM_CRYPTO_ERROR, + NM_CRYPTO_ERROR_FAILED, + _("Failed to initialize the encryption cipher slot.")); + return NULL; + } + + sym_key = PK11_ImportSymKey(slot, cipher_mech, PK11_OriginUnwrap, CKA_ENCRYPT, &key_item, NULL); + if (!sym_key) { + g_set_error(error, + NM_CRYPTO_ERROR, + NM_CRYPTO_ERROR_ENCRYPTION_FAILED, + _("Failed to set symmetric key for encryption.")); + goto out; + } + + sec_param = PK11_ParamFromIV(cipher_mech, &iv_item); + if (!sec_param) { + g_set_error(error, + NM_CRYPTO_ERROR, + NM_CRYPTO_ERROR_ENCRYPTION_FAILED, + _("Failed to set IV for encryption.")); + goto out; + } + + ctx = PK11_CreateContextBySymKey(cipher_mech, CKA_ENCRYPT, sym_key, sec_param); + if (!ctx) { + g_set_error(error, + NM_CRYPTO_ERROR, + NM_CRYPTO_ERROR_ENCRYPTION_FAILED, + _("Failed to initialize the encryption context.")); + goto out; + } + + /* If data->len % ivlen == 0, then we add another complete block + * onto the end so that the decrypter knows there's padding. + */ + pad_len = iv_len - (data_len % iv_len); + + padded_buf.len = data_len + pad_len; + padded_buf.bin = g_malloc(padded_buf.len); + + memcpy(padded_buf.bin, data, data_len); + for (i = 0; i < pad_len; i++) + padded_buf.bin[data_len + i] = (guint8)(pad_len & 0xFF); + + output.len = padded_buf.len; + output.bin = g_malloc(output.len); + + ret = + PK11_CipherOp(ctx, output.bin, &encrypted_len, output.len, padded_buf.bin, padded_buf.len); + if (ret != SECSuccess) { + g_set_error(error, + NM_CRYPTO_ERROR, + NM_CRYPTO_ERROR_ENCRYPTION_FAILED, + _("Failed to encrypt: %d."), + PORT_GetError()); + goto out; + } + + if (encrypted_len != output.len) { + g_set_error(error, + NM_CRYPTO_ERROR, + NM_CRYPTO_ERROR_ENCRYPTION_FAILED, + _("Unexpected amount of data after encrypting.")); + goto out; + } + + success = TRUE; out: - if (ctx) - PK11_DestroyContext (ctx, PR_TRUE); - if (sec_param) - SECITEM_FreeItem (sec_param, PR_TRUE); - if (sym_key) - PK11_FreeSymKey (sym_key); - if (slot) - PK11_FreeSlot (slot); - - if (!success) - return NULL; - - *out_len = output.len; - return g_steal_pointer (&output.bin); + if (ctx) + PK11_DestroyContext(ctx, PR_TRUE); + if (sec_param) + SECITEM_FreeItem(sec_param, PR_TRUE); + if (sym_key) + PK11_FreeSymKey(sym_key); + if (slot) + PK11_FreeSlot(slot); + + if (!success) + return NULL; + + *out_len = output.len; + return g_steal_pointer(&output.bin); } gboolean -_nm_crypto_verify_x509 (const guint8 *data, - gsize len, - GError **error) +_nm_crypto_verify_x509(const guint8 *data, gsize len, GError **error) { - CERTCertificate *cert; - - if (!_nm_crypto_init (error)) - return FALSE; - - /* Try DER/PEM first */ - cert = CERT_DecodeCertFromPackage ((char *) data, len); - if (!cert) { - g_set_error (error, NM_CRYPTO_ERROR, - NM_CRYPTO_ERROR_INVALID_DATA, - _("Couldn't decode certificate: %d"), - PORT_GetError ()); - return FALSE; - } - - CERT_DestroyCertificate (cert); - return TRUE; + CERTCertificate *cert; + + if (!_nm_crypto_init(error)) + return FALSE; + + /* Try DER/PEM first */ + cert = CERT_DecodeCertFromPackage((char *) data, len); + if (!cert) { + g_set_error(error, + NM_CRYPTO_ERROR, + NM_CRYPTO_ERROR_INVALID_DATA, + _("Couldn't decode certificate: %d"), + PORT_GetError()); + return FALSE; + } + + CERT_DestroyCertificate(cert); + return TRUE; } gboolean -_nm_crypto_verify_pkcs12 (const guint8 *data, - gsize data_len, - const char *password, - GError **error) +_nm_crypto_verify_pkcs12(const guint8 *data, gsize data_len, const char *password, GError **error) { - SEC_PKCS12DecoderContext *p12ctx = NULL; - SECItem pw = { 0 }; - PK11SlotInfo *slot = NULL; - SECStatus s; - gboolean success = FALSE; + SEC_PKCS12DecoderContext *p12ctx = NULL; + SECItem pw = {0}; + PK11SlotInfo * slot = NULL; + SECStatus s; + gboolean success = FALSE; - g_return_val_if_fail (!error || !*error, FALSE); + g_return_val_if_fail(!error || !*error, FALSE); - if (!_nm_crypto_init (error)) - return FALSE; + if (!_nm_crypto_init(error)) + return FALSE; - /* PKCS#12 passwords are apparently UCS2 BIG ENDIAN, and NSS doesn't do - * any conversions for us. - */ - if (password && *password) { - nm_auto_clear_secret_ptr NMSecretPtr ucs2_password = { 0 }; + /* PKCS#12 passwords are apparently UCS2 BIG ENDIAN, and NSS doesn't do + * any conversions for us. + */ + if (password && *password) { + nm_auto_clear_secret_ptr NMSecretPtr ucs2_password = {0}; - if (g_utf8_validate (password, -1, NULL)) { - long ucs2_chars; + if (g_utf8_validate(password, -1, NULL)) { + long ucs2_chars; - ucs2_password.bin = (guint8 *) g_utf8_to_utf16 (password, strlen (password), NULL, &ucs2_chars, NULL); + ucs2_password.bin = + (guint8 *) g_utf8_to_utf16(password, strlen(password), NULL, &ucs2_chars, NULL); - /* cannot fail, because password is valid UTF-8*/ - nm_assert (ucs2_password.bin && ucs2_chars > 0); + /* cannot fail, because password is valid UTF-8*/ + nm_assert(ucs2_password.bin && ucs2_chars > 0); - ucs2_password.len = ucs2_chars * 2; - } + ucs2_password.len = ucs2_chars * 2; + } - if (!ucs2_password.bin || ucs2_password.len == 0) { - g_set_error (error, NM_CRYPTO_ERROR, - NM_CRYPTO_ERROR_INVALID_PASSWORD, - _("Password must be UTF-8")); - return FALSE; - } + if (!ucs2_password.bin || ucs2_password.len == 0) { + g_set_error(error, + NM_CRYPTO_ERROR, + NM_CRYPTO_ERROR_INVALID_PASSWORD, + _("Password must be UTF-8")); + return FALSE; + } - pw.data = PORT_ZAlloc (ucs2_password.len + 2); - memcpy (pw.data, ucs2_password.bin, ucs2_password.len); - pw.len = ucs2_password.len + 2; + pw.data = PORT_ZAlloc(ucs2_password.len + 2); + memcpy(pw.data, ucs2_password.bin, ucs2_password.len); + pw.len = ucs2_password.len + 2; #if __BYTE_ORDER == __LITTLE_ENDIAN - { - guint16 *p, *p_end; + { + guint16 *p, *p_end; - p_end = (guint16 *) &(((guint8 *) pw.data)[ucs2_password.len]); - for (p = (guint16 *) pw.data; p < p_end; p++) - *p = GUINT16_SWAP_LE_BE (*p); - } + p_end = (guint16 *) &(((guint8 *) pw.data)[ucs2_password.len]); + for (p = (guint16 *) pw.data; p < p_end; p++) + *p = GUINT16_SWAP_LE_BE(*p); + } #endif - } - - slot = PK11_GetInternalKeySlot (); - if (!slot) { - g_set_error (error, NM_CRYPTO_ERROR, - NM_CRYPTO_ERROR_FAILED, - _("Couldn't initialize slot")); - goto out; - } - - p12ctx = SEC_PKCS12DecoderStart (&pw, slot, NULL, NULL, NULL, NULL, NULL, NULL); - if (!p12ctx) { - g_set_error (error, NM_CRYPTO_ERROR, - NM_CRYPTO_ERROR_FAILED, - _("Couldn't initialize PKCS#12 decoder: %d"), - PORT_GetError ()); - goto out; - } - - s = SEC_PKCS12DecoderUpdate (p12ctx, (guint8 *)data, data_len); - if (s != SECSuccess) { - g_set_error (error, NM_CRYPTO_ERROR, - NM_CRYPTO_ERROR_INVALID_DATA, - _("Couldn't decode PKCS#12 file: %d"), - PORT_GetError ()); - goto out; - } - - s = SEC_PKCS12DecoderVerify (p12ctx); - if (s != SECSuccess) { - g_set_error (error, NM_CRYPTO_ERROR, - NM_CRYPTO_ERROR_DECRYPTION_FAILED, - _("Couldn't verify PKCS#12 file: %d"), - PORT_GetError ()); - goto out; - } - - success = TRUE; + } + + slot = PK11_GetInternalKeySlot(); + if (!slot) { + g_set_error(error, NM_CRYPTO_ERROR, NM_CRYPTO_ERROR_FAILED, _("Couldn't initialize slot")); + goto out; + } + + p12ctx = SEC_PKCS12DecoderStart(&pw, slot, NULL, NULL, NULL, NULL, NULL, NULL); + if (!p12ctx) { + g_set_error(error, + NM_CRYPTO_ERROR, + NM_CRYPTO_ERROR_FAILED, + _("Couldn't initialize PKCS#12 decoder: %d"), + PORT_GetError()); + goto out; + } + + s = SEC_PKCS12DecoderUpdate(p12ctx, (guint8 *) data, data_len); + if (s != SECSuccess) { + g_set_error(error, + NM_CRYPTO_ERROR, + NM_CRYPTO_ERROR_INVALID_DATA, + _("Couldn't decode PKCS#12 file: %d"), + PORT_GetError()); + goto out; + } + + s = SEC_PKCS12DecoderVerify(p12ctx); + if (s != SECSuccess) { + g_set_error(error, + NM_CRYPTO_ERROR, + NM_CRYPTO_ERROR_DECRYPTION_FAILED, + _("Couldn't verify PKCS#12 file: %d"), + PORT_GetError()); + goto out; + } + + success = TRUE; out: - if (p12ctx) - SEC_PKCS12DecoderFinish (p12ctx); - if (slot) - PK11_FreeSlot (slot); + if (p12ctx) + SEC_PKCS12DecoderFinish(p12ctx); + if (slot) + PK11_FreeSlot(slot); - if (pw.data) - SECITEM_ZfreeItem (&pw, PR_FALSE); + if (pw.data) + SECITEM_ZfreeItem(&pw, PR_FALSE); - return success; + return success; } gboolean -_nm_crypto_verify_pkcs8 (const guint8 *data, - gsize data_len, - gboolean is_encrypted, - const char *password, - GError **error) +_nm_crypto_verify_pkcs8(const guint8 *data, + gsize data_len, + gboolean is_encrypted, + const char * password, + GError ** error) { - g_return_val_if_fail (data != NULL, FALSE); + g_return_val_if_fail(data != NULL, FALSE); - if (!_nm_crypto_init (error)) - return FALSE; + if (!_nm_crypto_init(error)) + return FALSE; - /* NSS apparently doesn't do PKCS#8 natively, but you have to put the - * PKCS#8 key into a PKCS#12 file and import that?? So until we figure - * all that out, we can only assume the password is valid. - */ - return TRUE; + /* NSS apparently doesn't do PKCS#8 natively, but you have to put the + * PKCS#8 key into a PKCS#12 file and import that?? So until we figure + * all that out, we can only assume the password is valid. + */ + return TRUE; } gboolean -_nm_crypto_randomize (void *buffer, gsize buffer_len, GError **error) +_nm_crypto_randomize(void *buffer, gsize buffer_len, GError **error) { - SECStatus s; - - if (!_nm_crypto_init (error)) - return FALSE; - - s = PK11_GenerateRandom (buffer, buffer_len); - if (s != SECSuccess) { - g_set_error_literal (error, NM_CRYPTO_ERROR, - NM_CRYPTO_ERROR_FAILED, - _("Could not generate random data.")); - return FALSE; - } - return TRUE; + SECStatus s; + + if (!_nm_crypto_init(error)) + return FALSE; + + s = PK11_GenerateRandom(buffer, buffer_len); + if (s != SECSuccess) { + g_set_error_literal(error, + NM_CRYPTO_ERROR, + NM_CRYPTO_ERROR_FAILED, + _("Could not generate random data.")); + return FALSE; + } + return TRUE; } |