--- /dev/null
+/*
+
+ silcpgp_pkcs.c
+
+ Author: Pekka Riikonen <priikone@silcnet.org>
+
+ Copyright (C) 2007 - 2008 Pekka Riikonen
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation; version 2 of the License.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
+
+*/
+
+#include "silccrypto.h"
+#include "rsa.h"
+#include "dsa.h"
+
+/**************************** OpenPGP PKCS API ******************************/
+
+/* Get algorithm context */
+
+SILC_PKCS_GET_ALGORITHM(silc_pkcs_pgp_get_algorithm)
+{
+ SilcPGPPublicKey pubkey = public_key;
+ return pubkey->pkcs;
+}
+
+/* Import PGP public key file */
+
+SILC_PKCS_IMPORT_PUBLIC_KEY_FILE(silc_pkcs_pgp_import_public_key_file)
+{
+ SilcList list;
+ SilcBool ret;
+ unsigned char *data = NULL;
+ SilcPGPPublicKey pubkey;
+
+ SILC_LOG_DEBUG(("Parsing OpenPGP public key file"));
+
+ if (!ret_public_key)
+ return FALSE;
+
+ switch (encoding) {
+ case SILC_PKCS_FILE_BIN:
+ break;
+
+ case SILC_PKCS_FILE_BASE64:
+ data = silc_pgp_dearmor(filedata, filedata_len, &filedata_len);
+ if (!data)
+ return FALSE;
+ filedata = data;
+ break;
+ }
+
+ /* Parse PGP packets */
+ if (!silc_pgp_packet_decode(filedata, filedata_len, NULL, &list)) {
+ silc_free(data);
+ return FALSE;
+ }
+ silc_free(data);
+
+ /* Parse the public key */
+ ret = silc_pgp_public_key_decode(&list, &pubkey);
+ if (ret) {
+ if (ret_alg)
+ *ret_alg = pubkey->pkcs;
+ if (ret_public_key)
+ *ret_public_key = pubkey;
+ }
+
+ silc_pgp_packet_free_list(&list);
+
+ return ret;
+}
+
+/* Import OpenPGP public key packet (OpenPGP certificate). */
+
+SILC_PKCS_IMPORT_PUBLIC_KEY(silc_pkcs_pgp_import_public_key)
+{
+ SilcPGPPublicKey pubkey;
+ int ret;
+
+ pubkey = silc_calloc(1, sizeof(*pubkey));
+ if (!pubkey)
+ return 0;
+
+ ret = silc_pgp_packet_public_key_decode(key, key_len, pubkey);
+ if (ret) {
+ if (ret_alg)
+ *ret_alg = pubkey->pkcs;
+ if (ret_public_key)
+ *ret_public_key = pubkey;
+ } else {
+ silc_free(pubkey);
+ }
+
+ return ret;
+}
+
+/* Export PGP public key file */
+
+SILC_PKCS_EXPORT_PUBLIC_KEY_FILE(silc_pkcs_pgp_export_public_key_file)
+{
+ return 0;
+}
+
+/* Export OpenPGP public key */
+
+SILC_PKCS_EXPORT_PUBLIC_KEY(silc_pkcs_pgp_export_public_key)
+{
+ return 0;
+}
+
+/* Return public key length in bits */
+
+SILC_PKCS_PUBLIC_KEY_BITLEN(silc_pkcs_pgp_public_key_bitlen)
+
+{
+ SilcPGPPublicKey pubkey = public_key;
+ return pubkey->pkcs->public_key_bitlen(pubkey->pkcs, pubkey->public_key);
+}
+
+/* Copy public key */
+
+SILC_PKCS_PUBLIC_KEY_COPY(silc_pkcs_pgp_public_key_copy)
+{
+ SilcPGPPublicKey pubkey = public_key, new_pubkey, p;
+ SilcPGPPacket packet;
+
+ new_pubkey = silc_calloc(1, sizeof(*new_pubkey));
+ if (!new_pubkey)
+ return NULL;
+
+ if (pubkey->subkeys) {
+ new_pubkey->subkeys = silc_dlist_init();
+ if (!new_pubkey->subkeys) {
+ silc_free(new_pubkey);
+ return NULL;
+ }
+
+ silc_dlist_start(pubkey->subkeys);
+ while ((p = silc_dlist_get(pubkey->subkeys))) {
+ p = silc_pkcs_pgp_public_key_copy(pkcs, p);
+ if (p)
+ silc_dlist_add(new_pubkey->subkeys, p);
+ }
+ }
+
+ silc_list_init(new_pubkey->packets, struct SilcPGPPacketStruct, next);
+ silc_list_start(pubkey->packets);
+ while ((packet = silc_list_get(pubkey->packets))) {
+ packet = silc_pgp_packet_copy(packet);
+ if (packet) {
+ silc_free(new_pubkey);
+ return NULL;
+ }
+ silc_list_add(new_pubkey->packets, packet);
+ }
+
+ memcpy(new_pubkey->key_id, pubkey->key_id, sizeof(pubkey->key_id));
+ memcpy(new_pubkey->fingerprint, pubkey->fingerprint,
+ sizeof(pubkey->fingerprint));
+ new_pubkey->created = pubkey->created;
+ new_pubkey->valid = pubkey->valid;
+ new_pubkey->version = pubkey->version;
+ new_pubkey->algorithm = pubkey->algorithm;
+
+ new_pubkey->public_key = pubkey->pkcs->public_key_copy(pubkey->pkcs,
+ pubkey->public_key);
+ if (!new_pubkey->public_key) {
+ silc_free(new_pubkey);
+ return NULL;
+ }
+
+ return new_pubkey;
+}
+
+/* Compares public keys */
+
+SILC_PKCS_PUBLIC_KEY_COMPARE(silc_pkcs_pgp_public_key_compare)
+{
+ SilcPGPPublicKey k1 = key1, k2 = key2;
+
+ if (k1->version != k2->version)
+ return FALSE;
+ if (k1->created != k2->created)
+ return FALSE;
+ if (k1->valid != k2->valid)
+ return FALSE;
+ if (k1->algorithm != k2->algorithm)
+ return FALSE;
+ if (memcmp(k1->key_id, k2->key_id, sizeof(k1->key_id)))
+ return FALSE;
+ if (memcmp(k1->fingerprint, k2->fingerprint, sizeof(k1->fingerprint)))
+ return FALSE;
+
+ return k1->pkcs->public_key_compare(k1->pkcs,
+ k1->public_key, k2->public_key);
+}
+
+/* Free public key */
+
+SILC_PKCS_PUBLIC_KEY_FREE(silc_pkcs_pgp_public_key_free)
+{
+ silc_pgp_public_key_free(public_key);
+}
+
+/* Import PGP private key file */
+
+SILC_PKCS_IMPORT_PRIVATE_KEY_FILE(silc_pkcs_pgp_import_private_key_file)
+{
+ SilcList list;
+ SilcBool ret;
+ unsigned char *data = NULL;
+ SilcPGPPrivateKey privkey;
+
+ SILC_LOG_DEBUG(("Parsing OpenPGP private key file"));
+
+ if (!ret_private_key)
+ return FALSE;
+
+ switch (encoding) {
+ case SILC_PKCS_FILE_BIN:
+ break;
+
+ case SILC_PKCS_FILE_BASE64:
+ data = silc_pgp_dearmor(filedata, filedata_len, &filedata_len);
+ if (!data)
+ return FALSE;
+ filedata = data;
+ break;
+ }
+
+ /* Parse PGP packets */
+ if (!silc_pgp_packet_decode(filedata, filedata_len, NULL, &list)) {
+ silc_free(data);
+ return FALSE;
+ }
+ silc_free(data);
+
+ /* Parse the private key */
+ ret = silc_pgp_private_key_decode(&list, passphrase, passphrase_len,
+ &privkey);
+ if (ret) {
+ if (ret_alg)
+ *ret_alg = privkey->public_key->pkcs;
+ if (ret_private_key)
+ *ret_private_key = privkey;
+ }
+
+ silc_pgp_packet_free_list(&list);
+
+ return ret;
+}
+
+/* Import OpenPGP private key */
+
+SILC_PKCS_IMPORT_PRIVATE_KEY(silc_pkcs_pgp_import_private_key)
+{
+ SilcPGPPrivateKey privkey;
+ int ret;
+
+ privkey = silc_calloc(1, sizeof(*privkey));
+ if (!privkey)
+ return 0;
+
+ ret = silc_pgp_packet_private_key_decode(key, key_len, passphrase,
+ passphrase_len, privkey);
+ if (ret) {
+ if (ret_alg)
+ *ret_alg = privkey->public_key->pkcs;
+ if (ret_private_key)
+ *ret_private_key = privkey;
+ } else {
+ silc_free(privkey);
+ }
+
+ return ret;
+}
+
+/* Export PGP private key file */
+
+SILC_PKCS_EXPORT_PRIVATE_KEY_FILE(silc_pkcs_pgp_export_private_key_file)
+{
+ return 0;
+}
+
+/* Export OpenPGP private key */
+
+SILC_PKCS_EXPORT_PRIVATE_KEY(silc_pkcs_pgp_export_private_key)
+{
+ return 0;
+}
+
+/* Returns key length in bits */
+
+SILC_PKCS_PRIVATE_KEY_BITLEN(silc_pkcs_pgp_private_key_bitlen)
+{
+ SilcPGPPrivateKey privkey = private_key;
+ return silc_pkcs_pgp_public_key_bitlen(pkcs, privkey->public_key);
+}
+
+/* Free private key */
+
+SILC_PKCS_PRIVATE_KEY_FREE(silc_pkcs_pgp_private_key_free)
+{
+ SilcPGPPrivateKey privkey = private_key;
+ silc_pgp_private_key_free(privkey);
+}
+
+/* Encrypt */
+
+SILC_PKCS_ENCRYPT(silc_pkcs_pgp_encrypt)
+{
+ return 0;
+}
+
+/* Decrypt */
+
+SILC_PKCS_DECRYPT(silc_pkcs_pgp_decrypt)
+{
+ return 0;
+}
+
+/* Sign */
+
+SILC_PKCS_SIGN(silc_pkcs_pgp_sign)
+{
+ return 0;
+}
+
+/* Verify */
+
+SILC_PKCS_VERIFY(silc_pkcs_pgp_verify)
+{
+ return 0;
+}
+
+/************************** OpenPGP RSA PKCS API ****************************/
+
+/* Import OpenPGP compliant RSA public key */
+
+SILC_PKCS_ALG_IMPORT_PUBLIC_KEY(silc_pgp_rsa_import_public_key)
+{
+ SilcBufferStruct alg_key;
+ RsaPublicKey *pubkey;
+ unsigned char *n, *e;
+ SilcUInt16 n_len, e_len;
+
+ if (!ret_public_key)
+ return 0;
+
+ /* Allocate RSA public key */
+ *ret_public_key = pubkey = silc_calloc(1, sizeof(*pubkey));
+ if (!pubkey)
+ return FALSE;
+
+ /* Parse OpenPGP RSA public key */
+ silc_buffer_set(&alg_key, key, key_len);
+ if (silc_buffer_unformat(&alg_key,
+ SILC_STR_ADVANCE,
+ SILC_STR_UINT16(&n_len),
+ SILC_STR_END) < 0)
+ goto err;
+
+ n_len = (n_len + 7) / 8;
+ if (!n_len)
+ goto err;
+
+ if (silc_buffer_unformat(&alg_key,
+ SILC_STR_ADVANCE,
+ SILC_STR_DATA(&n, n_len),
+ SILC_STR_UINT16(&e_len),
+ SILC_STR_END) < 0)
+ goto err;
+
+ e_len = (e_len + 7) / 8;
+ if (!e_len)
+ goto err;
+
+ if (silc_buffer_unformat(&alg_key,
+ SILC_STR_ADVANCE,
+ SILC_STR_DATA(&e, e_len),
+ SILC_STR_END) < 0)
+ goto err;
+
+ /* Get MP integers */
+ silc_mp_init(&pubkey->n);
+ silc_mp_init(&pubkey->e);
+ silc_mp_bin2mp(n, n_len, &pubkey->n);
+ silc_mp_bin2mp(e, e_len, &pubkey->e);
+
+ /* Set key length */
+ pubkey->bits = silc_mp_sizeinbase(&pubkey->n, 2);
+
+ return silc_buffer_headlen(&alg_key);
+
+ err:
+ silc_free(pubkey);
+ return 0;
+}
+
+/* Export OpenPGP compliant RSA public key */
+
+SILC_PKCS_ALG_EXPORT_PUBLIC_KEY(silc_pgp_rsa_export_public_key)
+{
+ RsaPublicKey *pubkey = public_key;
+ SilcBufferStruct alg_key;
+ unsigned char *n = NULL, *e = NULL, *ret;
+ SilcUInt16 n_len, e_len;
+
+ n_len = silc_mp_sizeinbase(&pubkey->n, 2);
+ e_len = silc_mp_sizeinbase(&pubkey->e, 2);
+
+ /* Encode MP integers */
+ n = silc_mp_mp2bin(&pubkey->n, 0, NULL);
+ if (!n)
+ goto err;
+ e = silc_mp_mp2bin(&pubkey->e, 0, NULL);
+ if (!e)
+ goto err;
+
+ memset(&alg_key, 0, sizeof(alg_key));
+ if (silc_buffer_format(&alg_key,
+ SILC_STR_UINT16(n_len),
+ SILC_STR_DATA(n, n_len),
+ SILC_STR_UINT16(e_len),
+ SILC_STR_DATA(e, e_len),
+ SILC_STR_END) < 0)
+ goto err;
+
+ silc_free(n);
+ silc_free(e);
+
+ ret = silc_buffer_steal(&alg_key, ret_len);
+ return ret;
+
+ err:
+ silc_free(n);
+ silc_free(e);
+ return NULL;
+}
+
+/* Import OpenPGP compliant RSA private key */
+
+SILC_PKCS_ALG_IMPORT_PRIVATE_KEY(silc_pgp_rsa_import_private_key)
+{
+ SilcBufferStruct alg_key;
+ RsaPrivateKey *privkey;
+ unsigned char *d, *p, *q, *u;
+ SilcUInt16 d_len, p_len, q_len, u_len;
+ SilcMPInt pm1, qm1;
+
+ if (!ret_private_key)
+ return 0;
+
+ /* Allocate RSA private key */
+ *ret_private_key = privkey = silc_calloc(1, sizeof(*privkey));
+ if (!privkey)
+ goto err;
+
+ /* Parse OpenPGP RSA private key. In OpenPGP the u is p^-1 mod q, but
+ our RSA implementation expects q^-1 mod p (PKCS#1 compliant), thus
+ we reverse p and q to make it work. */
+ silc_buffer_set(&alg_key, key, key_len);
+ if (silc_buffer_unformat(&alg_key,
+ SILC_STR_ADVANCE,
+ SILC_STR_UINT16(&d_len),
+ SILC_STR_END) < 0)
+ goto err;
+
+ d_len = (d_len + 7) / 8;
+ if (!d_len)
+ goto err;
+
+ if (silc_buffer_unformat(&alg_key,
+ SILC_STR_ADVANCE,
+ SILC_STR_DATA(&d, d_len),
+ SILC_STR_UINT16(&q_len),
+ SILC_STR_END) < 0)
+ goto err;
+
+ q_len = (q_len + 7) / 8;
+ if (!q_len)
+ goto err;
+
+ if (silc_buffer_unformat(&alg_key,
+ SILC_STR_ADVANCE,
+ SILC_STR_DATA(&q, q_len),
+ SILC_STR_UINT16(&p_len),
+ SILC_STR_END) < 0)
+ goto err;
+
+ p_len = (p_len + 7) / 8;
+ if (!p_len)
+ goto err;
+
+ if (silc_buffer_unformat(&alg_key,
+ SILC_STR_ADVANCE,
+ SILC_STR_DATA(&p, p_len),
+ SILC_STR_UINT16(&u_len),
+ SILC_STR_END) < 0)
+ goto err;
+
+ u_len = (u_len + 7) / 8;
+ if (!u_len)
+ goto err;
+
+ if (silc_buffer_unformat(&alg_key,
+ SILC_STR_ADVANCE,
+ SILC_STR_DATA(&u, u_len),
+ SILC_STR_END) < 0)
+ goto err;
+
+ /* Get MP integers */
+ silc_mp_init(&privkey->d);
+ silc_mp_init(&privkey->p);
+ silc_mp_init(&privkey->q);
+ silc_mp_init(&privkey->qP);
+ silc_mp_bin2mp(d, d_len, &privkey->d);
+ silc_mp_bin2mp(p, p_len, &privkey->p);
+ silc_mp_bin2mp(q, q_len, &privkey->q);
+ silc_mp_bin2mp(u, u_len, &privkey->qP);
+
+ /* Fill in missing integers and pre-compute */
+ silc_mp_init(&pm1);
+ silc_mp_init(&qm1);
+ silc_mp_init(&privkey->n);
+ silc_mp_init(&privkey->e);
+ silc_mp_init(&privkey->dP);
+ silc_mp_init(&privkey->dQ);
+ silc_mp_mul(&privkey->n, &privkey->p, &privkey->q);
+ silc_mp_sub_ui(&pm1, &privkey->p, 1);
+ silc_mp_sub_ui(&qm1, &privkey->q, 1);
+ silc_mp_mod(&privkey->dP, &privkey->d, &pm1);
+ silc_mp_mod(&privkey->dQ, &privkey->d, &qm1);
+ silc_mp_uninit(&pm1);
+ silc_mp_uninit(&qm1);
+
+ /* Set key length */
+ privkey->bits = silc_mp_sizeinbase(&privkey->n, 2);
+
+ return silc_buffer_headlen(&alg_key);
+
+ err:
+ silc_free(privkey);
+ return 0;
+}
+
+/* Export OpenPGP compliant RSA private key */
+
+SILC_PKCS_ALG_EXPORT_PRIVATE_KEY(silc_pgp_rsa_export_private_key)
+{
+ RsaPrivateKey *privkey = private_key;
+ SilcBufferStruct alg_key;
+ unsigned char *d = NULL, *p = NULL, *q = NULL, *u = NULL, *ret;
+ SilcUInt16 d_len, p_len, q_len, u_len;
+
+ /* In OpenPGP the u is p^-1 mod q, but our RSA implementation uses
+ q^-1 mod p (PKCS#1 compliant), thus we reverse p and q to make the
+ key correct. */
+ d_len = silc_mp_sizeinbase(&privkey->d, 2);
+ p_len = silc_mp_sizeinbase(&privkey->q, 2);
+ q_len = silc_mp_sizeinbase(&privkey->p, 2);
+ u_len = silc_mp_sizeinbase(&privkey->qP, 2);
+
+ /* Encode MP integers */
+ d = silc_mp_mp2bin(&privkey->d, 0, NULL);
+ if (!d)
+ goto err;
+ p = silc_mp_mp2bin(&privkey->q, 0, NULL);
+ if (!p)
+ goto err;
+ q = silc_mp_mp2bin(&privkey->p, 0, NULL);
+ if (!q)
+ goto err;
+ u = silc_mp_mp2bin(&privkey->qP, 0, NULL);
+ if (!u)
+ goto err;
+
+ memset(&alg_key, 0, sizeof(alg_key));
+ if (silc_buffer_format(&alg_key,
+ SILC_STR_UINT16(d_len),
+ SILC_STR_DATA(d, d_len),
+ SILC_STR_UINT16(p_len),
+ SILC_STR_DATA(p, p_len),
+ SILC_STR_UINT16(q_len),
+ SILC_STR_DATA(q, q_len),
+ SILC_STR_UINT16(u_len),
+ SILC_STR_DATA(u, u_len),
+ SILC_STR_END) < 0)
+ goto err;
+
+ silc_free(d);
+ silc_free(p);
+ silc_free(q);
+ silc_free(u);
+
+ ret = silc_buffer_steal(&alg_key, ret_len);
+ return ret;
+
+ err:
+ silc_free(d);
+ silc_free(p);
+ silc_free(q);
+ silc_free(u);
+ return NULL;
+}
+
+/************************** OpenPGP DSA PKCS API ****************************/
+
+/* Import OpenPGP compliant DSA public key */
+
+SILC_PKCS_ALG_IMPORT_PUBLIC_KEY(silc_pgp_dsa_import_public_key)
+{
+ SilcBufferStruct alg_key;
+ DsaPublicKey *pubkey;
+ unsigned char *p, *q, *g, *y;
+ SilcUInt16 p_len, q_len, g_len, y_len;
+
+ if (!ret_public_key)
+ return 0;
+
+ /* Allocate DSA public key */
+ *ret_public_key = pubkey = silc_calloc(1, sizeof(*pubkey));
+ if (!pubkey)
+ return FALSE;
+
+ /* Parse OpenPGP DSA public key */
+ silc_buffer_set(&alg_key, key, key_len);
+ if (silc_buffer_unformat(&alg_key,
+ SILC_STR_ADVANCE,
+ SILC_STR_UINT16(&p_len),
+ SILC_STR_END) < 0)
+ goto err;
+
+ p_len = (p_len + 7) / 8;
+ if (!p_len)
+ goto err;
+
+ if (silc_buffer_unformat(&alg_key,
+ SILC_STR_ADVANCE,
+ SILC_STR_DATA(&p, p_len),
+ SILC_STR_UINT16(&q_len),
+ SILC_STR_END) < 0)
+ goto err;
+
+ q_len = (q_len + 7) / 8;
+ if (!q_len)
+ goto err;
+
+ if (silc_buffer_unformat(&alg_key,
+ SILC_STR_ADVANCE,
+ SILC_STR_DATA(&q, q_len),
+ SILC_STR_UINT16(&g_len),
+ SILC_STR_END) < 0)
+ goto err;
+
+ g_len = (g_len + 7) / 8;
+ if (!g_len)
+ goto err;
+
+ if (silc_buffer_unformat(&alg_key,
+ SILC_STR_ADVANCE,
+ SILC_STR_DATA(&g, g_len),
+ SILC_STR_UINT16(&y_len),
+ SILC_STR_END) < 0)
+ goto err;
+
+ y_len = (y_len + 7) / 8;
+ if (!y_len)
+ goto err;
+
+ if (silc_buffer_unformat(&alg_key,
+ SILC_STR_ADVANCE,
+ SILC_STR_DATA(&y, y_len),
+ SILC_STR_END) < 0)
+ goto err;
+
+ /* Get MP integers */
+ silc_mp_init(&pubkey->p);
+ silc_mp_init(&pubkey->q);
+ silc_mp_init(&pubkey->g);
+ silc_mp_init(&pubkey->y);
+ silc_mp_bin2mp(p, p_len, &pubkey->p);
+ silc_mp_bin2mp(q, q_len, &pubkey->q);
+ silc_mp_bin2mp(g, g_len, &pubkey->g);
+ silc_mp_bin2mp(y, y_len, &pubkey->y);
+
+ /* Set key length */
+ pubkey->bits = silc_mp_sizeinbase(&pubkey->p, 2);
+
+ return silc_buffer_headlen(&alg_key);
+
+ err:
+ silc_free(pubkey);
+ return 0;
+}
+
+/* Export OpenPGP compliant DSA public key */
+
+SILC_PKCS_ALG_EXPORT_PUBLIC_KEY(silc_pgp_dsa_export_public_key)
+{
+ return 0;
+}
+
+/* Import OpenPGP compliant DSA private key */
+
+SILC_PKCS_ALG_IMPORT_PRIVATE_KEY(silc_pgp_dsa_import_private_key)
+{
+ SilcBufferStruct alg_key;
+ DsaPrivateKey *privkey;
+ unsigned char *x;
+ SilcUInt16 x_len;
+
+ if (!ret_private_key)
+ return 0;
+
+ /* Allocate DSA private key */
+ *ret_private_key = privkey = silc_calloc(1, sizeof(*privkey));
+ if (!privkey)
+ goto err;
+
+ /* Parse OpenPGP DSA private key. */
+ silc_buffer_set(&alg_key, key, key_len);
+ if (silc_buffer_unformat(&alg_key,
+ SILC_STR_ADVANCE,
+ SILC_STR_UINT16(&x_len),
+ SILC_STR_END) < 0)
+ goto err;
+
+ x_len = (x_len + 7) / 8;
+ if (!x_len)
+ goto err;
+
+ if (silc_buffer_unformat(&alg_key,
+ SILC_STR_ADVANCE,
+ SILC_STR_DATA(&x, x_len),
+ SILC_STR_END) < 0)
+ goto err;
+
+ /* Get MP integers */
+ silc_mp_init(&privkey->x);
+ silc_mp_bin2mp(x, x_len, &privkey->x);
+
+ return silc_buffer_headlen(&alg_key);
+
+ err:
+ silc_free(privkey);
+ return 0;
+}
+
+/* Export OpenPGP compliant DSA private key */
+
+SILC_PKCS_ALG_EXPORT_PRIVATE_KEY(silc_pgp_dsa_export_private_key)
+{
+ return 0;
+}
projects / crypto.git / blobdiff