encrypt.c \
decrypt.c \
verify.c \
+ sign.c \
key.c key.h \
keylist.c \
rungpg.c rungpg.h status-table.h \
RESULT_TYPE_NONE = 0,
RESULT_TYPE_VERIFY,
RESULT_TYPE_DECRYPT,
+ RESULT_TYPE_SIGN,
} ResultType;
GpgObject gpg; /* the running gpg process */
int verbosity; /* level of verbosity to use */
- int use_armor; /* use armoring */
-
+ int use_armor;
+ int use_textmode;
-
ResultType result_type;
union {
VerifyResult verify;
DecryptResult decrypt;
+ SignResult sign;
} result;
GpgmeData notation; /* last signature notation */
err = mk_error (Out_Of_Core);
else {
assert ( c->result.decrypt );
- if ( c->result.decrypt->failed )
+ if ( c->result.decrypt->no_passphrase )
+ err = mk_error (No_Passphrase);
+ else if ( c->result.decrypt->failed )
err = mk_error (Decryption_Failed);
else if (!c->result.decrypt->okay)
err = mk_error (No_Data);
if (!c)
return mk_error (Out_Of_Core);
c->verbosity = 1;
- c->use_armor = 1;
+ c->use_armor = 1; /* fixme: reset this to 0 */
*r_ctx = c;
return 0;
}
case RESULT_TYPE_DECRYPT:
_gpgme_release_decrypt_result ( c->result.decrypt );
break;
+ case RESULT_TYPE_SIGN:
+ _gpgme_release_sign_result ( c->result.sign );
+ break;
}
c->result.verify = NULL;
}
+void
+gpgme_op_set_armor ( GpgmeCtx c, int yes )
+{
+ if ( !c )
+ return; /* oops */
+ c->use_armor = yes;
+}
-
+void
+gpgme_op_set_textmode ( GpgmeCtx c, int yes )
+{
+ if ( !c )
+ return; /* oops */
+ c->use_textmode = yes;
+}
GPGME_Invalid_Mode = 16,
GPGME_File_Error = 17, /* errno is set in this case */
GPGME_Decryption_Failed = 18,
+ GPGME_No_Passphrase = 19,
} GpgmeError;
typedef enum {
GpgmeCtx gpgme_wait ( GpgmeCtx c, int hang );
char *gpgme_op_get_notation ( GpgmeCtx c );
+void gpgme_op_set_armor ( GpgmeCtx c, int yes );
+void gpgme_op_set_textmode ( GpgmeCtx c, int yes );
/* Functions to handle recipients */
GpgmeData in, GpgmeData out );
GpgmeError gpgme_op_decrypt_start ( GpgmeCtx c,
GpgmeData ciph, GpgmeData plain );
+GpgmeError gpgme_op_sign_start ( GpgmeCtx c, GpgmeData in, GpgmeData out );
GpgmeError gpgme_op_verify_start ( GpgmeCtx c,
GpgmeData sig, GpgmeData text );
GpgmeError gpgme_op_encrypt ( GpgmeCtx c, GpgmeRecipients recp,
GpgmeData in, GpgmeData out );
GpgmeError gpgme_op_decrypt ( GpgmeCtx c, GpgmeData in, GpgmeData out );
+GpgmeError gpgme_op_sign ( GpgmeCtx c, GpgmeData in, GpgmeData out );
GpgmeError gpgme_op_verify ( GpgmeCtx c, GpgmeData sig, GpgmeData text,
GpgmeSigStat *r_status );
/*-- decrypt.c --*/
void _gpgme_release_decrypt_result ( DecryptResult res );
+/*-- sign.c --*/
+void _gpgme_release_sign_result ( SignResult res );
+
#endif /* OPS_H */
}
/* We normally don't want all the normal output */
if ( !duped_stderr ) {
- if ( dup2 ( fd, 2 ) == -1 ) {
- fprintf (stderr,"dup2(dev/null, 2) failed: %s\n",
- strerror (errno) );
- _exit (8);
+ if (!getenv ("GPGME_DEBUG") ) {
+ if ( dup2 ( fd, 2 ) == -1 ) {
+ fprintf (stderr,"dup2(dev/null, 2) failed: %s\n",
+ strerror (errno) );
+ _exit (8);
+ }
}
}
close (fd);
--- /dev/null
+/* sign.c - signing functions
+ * Copyright (C) 2000 Werner Koch (dd9jn)
+ *
+ * This file is part of GPGME.
+ *
+ * GPGME 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; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * GPGME 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.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
+ */
+
+#include <config.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <assert.h>
+
+#include "util.h"
+#include "context.h"
+#include "ops.h"
+
+
+struct sign_result_s {
+ int no_passphrase;
+ int okay;
+};
+
+
+void
+_gpgme_release_sign_result ( SignResult res )
+{
+ xfree (res);
+}
+
+
+
+static void
+sign_status_handler ( GpgmeCtx ctx, GpgStatusCode code, char *args )
+{
+ if ( ctx->out_of_core )
+ return;
+ if ( ctx->result_type == RESULT_TYPE_NONE ) {
+ assert ( !ctx->result.sign );
+ ctx->result.sign = xtrycalloc ( 1, sizeof *ctx->result.sign );
+ if ( !ctx->result.sign ) {
+ ctx->out_of_core = 1;
+ return;
+ }
+ ctx->result_type = RESULT_TYPE_SIGN;
+ }
+ assert ( ctx->result_type == RESULT_TYPE_SIGN );
+
+ switch (code) {
+ case STATUS_EOF:
+ break;
+
+ case STATUS_NEED_PASSPHRASE:
+ case STATUS_NEED_PASSPHRASE_SYM:
+ fprintf (stderr, "Ooops: Need a passphrase - use the agent\n");
+ break;
+
+ case STATUS_MISSING_PASSPHRASE:
+ fprintf (stderr, "Missing passphrase - stop\n");;
+ ctx->result.sign->no_passphrase = 1;
+ break;
+
+ case STATUS_SIG_CREATED:
+ /* fixme: we have no error return for multible signatures */
+ ctx->result.sign->okay =1;
+ break;
+
+ default:
+ fprintf (stderr, "sign_status: code=%d not handled\n", code );
+ break;
+ }
+}
+
+
+
+GpgmeError
+gpgme_op_sign_start ( GpgmeCtx c, GpgmeData in, GpgmeData out )
+{
+ int rc = 0;
+ int i;
+
+ fail_on_pending_request( c );
+ c->pending = 1;
+
+ _gpgme_release_result (c);
+ c->out_of_core = 0;
+
+ /* do some checks */
+ assert ( !c->gpg );
+
+ /* create a process object */
+ rc = _gpgme_gpg_new ( &c->gpg );
+ if (rc)
+ goto leave;
+
+ _gpgme_gpg_set_status_handler ( c->gpg, sign_status_handler, c );
+
+ /* build the commandline */
+ _gpgme_gpg_add_arg ( c->gpg, "--sign" );
+ _gpgme_gpg_add_arg ( c->gpg, "--detach" );
+ if ( c->use_armor )
+ _gpgme_gpg_add_arg ( c->gpg, "--armor" );
+ if ( c->use_textmode )
+ _gpgme_gpg_add_arg ( c->gpg, "--textmode" );
+ for ( i=0; i < c->verbosity; i++ )
+ _gpgme_gpg_add_arg ( c->gpg, "--verbose" );
+
+ /* Check the supplied data */
+ if ( gpgme_data_get_type (in) == GPGME_DATA_TYPE_NONE ) {
+ rc = mk_error (No_Data);
+ goto leave;
+ }
+ _gpgme_data_set_mode (in, GPGME_DATA_MODE_OUT );
+ if ( !out || gpgme_data_get_type (out) != GPGME_DATA_TYPE_NONE ) {
+ rc = mk_error (Invalid_Value);
+ goto leave;
+ }
+ _gpgme_data_set_mode (out, GPGME_DATA_MODE_IN );
+
+ /* Tell the gpg object about the data */
+ _gpgme_gpg_add_data ( c->gpg, in, 0 );
+ _gpgme_gpg_add_data ( c->gpg, out, 1 );
+
+ /* and kick off the process */
+ rc = _gpgme_gpg_spawn ( c->gpg, c );
+
+ leave:
+ if (rc) {
+ c->pending = 0;
+ _gpgme_gpg_release ( c->gpg ); c->gpg = NULL;
+ }
+ return rc;
+}
+
+
+/**
+ * gpgme_op_sign:
+ * @c: The context
+ * @in: Data to be signed
+ * @out: Detached signature
+ *
+ * Create a detached signature for @in and write it to @out.
+ * The data will be signed using either the default key or the ones
+ * defined through @c.
+ *
+ * Return value: 0 on success or an error code.
+ **/
+GpgmeError
+gpgme_op_sign ( GpgmeCtx c, GpgmeData in, GpgmeData out )
+{
+ GpgmeError err = gpgme_op_sign_start ( c, in, out );
+ if ( !err ) {
+ gpgme_wait (c, 1);
+ if ( c->result_type != RESULT_TYPE_SIGN )
+ err = mk_error (General_Error);
+ else if ( c->out_of_core )
+ err = mk_error (Out_Of_Core);
+ else {
+ assert ( c->result.sign );
+ if ( c->result.sign->no_passphrase )
+ err = mk_error (No_Passphrase);
+ else if (!c->result.sign->okay)
+ err = mk_error (No_Data); /* Hmmm: choose a better error? */
+ }
+ c->pending = 0;
+ }
+ return err;
+}
+
+
+
+
+
+
+
+
+
struct decrypt_result_s;
typedef struct decrypt_result_s *DecryptResult;
+/*-- sign.c --*/
+struct sign_result_s;
+typedef struct sign_result_s *SignResult;
+
/*-- key.c --*/
## Process this file with automake to create Makefile.in
-TESTS = t-encrypt t-decrypt t-verify t-keylist
+TESTS = t-encrypt t-sign t-decrypt t-verify t-keylist
-EXTRA_DIST = cipher-1.asc
+EXTRA_DIST = cipher-1.asc geheim.txt
INCLUDES = -I$(top_srcdir)/include -I$(top_srcdir)/intl
--- /dev/null
+Wenn Sie dies lesen können, ist es wohl nicht
+geheim genug.
--- /dev/null
+/* t-sign.c - regression test
+ * Copyright (C) 2000 Werner Koch (dd9jn)
+ *
+ * This file is part of GPGME.
+ *
+ * GPGME 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; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * GPGME 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.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <assert.h>
+
+#include "../gpgme/gpgme.h"
+
+#define fail_if_err(a) do { if(a) { \
+ fprintf (stderr, "%s:%d: GpgmeError %s\n", \
+ __FILE__, __LINE__, gpgme_strerror(a)); \
+ exit (1); } \
+ } while(0)
+
+static void
+print_data ( GpgmeData dh )
+{
+ char buf[100];
+ size_t nread;
+ GpgmeError err;
+
+ err = gpgme_data_rewind ( dh );
+ fail_if_err (err);
+ while ( !(err = gpgme_data_read ( dh, buf, 100, &nread )) ) {
+ fwrite ( buf, nread, 1, stdout );
+ }
+ if (err != GPGME_EOF)
+ fail_if_err (err);
+}
+
+
+
+int
+main (int argc, char **argv )
+{
+ GpgmeCtx ctx;
+ GpgmeError err;
+ GpgmeData in, out;
+
+ do {
+ err = gpgme_new (&ctx);
+ fail_if_err (err);
+
+ err = gpgme_data_new_from_mem ( &in, "Hallo Leute\n", 12, 0 );
+ fail_if_err (err);
+
+ err = gpgme_data_new ( &out );
+ fail_if_err (err);
+
+ gpgme_op_set_textmode (ctx, 1);
+ gpgme_op_set_armor (ctx, 1);
+ err = gpgme_op_sign (ctx, in, out );
+ fail_if_err (err);
+
+ fflush (NULL);
+ fputs ("Begin Result:\n", stdout );
+ print_data (out);
+ fputs ("End Result.\n", stdout );
+
+ gpgme_data_release (in);
+ gpgme_data_release (out);
+ gpgme_release (ctx);
+ } while ( argc > 1 && !strcmp( argv[1], "--loop" ) );
+
+ return 0;
+}
+
+
+
+
projects / gpgme.git / commitdiff