Page MenuHome GnuPG
Files F34572364

No OneTemporary
Actions

View Options

This file is larger than 256 KB, so syntax highlighting was skipped.
This document is not UTF8. It was detected as ISO-8859-1 (Latin 1) and converted to UTF8 for display.
diff --git a/AUTHORS b/AUTHORS
index 8a4fb949f..062af1029 100644
--- a/AUTHORS
+++ b/AUTHORS
@@ -1,69 +1,72 @@
Authors of GNU Privacy Guard (GnuPG).
Werner Koch. Designed and implemented GnuPG.
GNUPG Matthew Skala 1998-08-10
Disclaims changes.
mskala@ansuz.sooke.bc.ca
Wrote cipher/twofish.c.
GNUPG Natural Resources Canada 1998-08-11
Disclaims changes by Matthew Skala.
GNUPG Michael Roth Germany 1998-09-17
Assigns changes.
mroth@nessie.de
Wrote cipher/des.c.
GNUPG Niklas Hernaeus 1998-09-18
Disclaims changes.
nh@df.lth.se
Weak key patches.
TRANSLATIONS Marco d'Itri 1997-02-22
Disclaimer. [it]
md@linux.it
TRANSLATIONS Gael Queri 1998-09-08
Disclaimer. [fr]
gqueri@mail.dotcom.fr
TRANSLATIONS Walter Koch 1998-09-08
Disclaimer. [de]
walterk@dip.de
TRANSLATIONS Gregory Steuck 1998-10-20
Disclaimer. [ru?]
steuck@iname.com
TRANSLATIONS Urko Lusa ??????????
es_ES.po
TRANSLATIONS Thiago Jung Bauermann ????????????????
pt_BR.po
Other notes:
============
This program uses the zlib compression library written by
Jean-loup Gailly and Mark Adler.
Most of the stuff in mpi has been taken from the GMP library.
The file cipher/rndunix.c is heavily based on Peter Gutmann's
rndunix.c from cryptlib. - He promised to add the GPL as an alternative
-license to this and some other files. We don't have a dissclaimer for
+license to this and some other files. We don't have a disclaimer for
this file, but due to the fact that this is only needed for non-free
system we can easily remove this from the distribution and put it as
a module on some FTP server.
+The RPM specs file scripts/gnupg.specs has been contributed by
+Caskey L. Dickson and Reuben Sumner.
+
diff --git a/NEWS b/NEWS
index 1e7d9300f..5683b98bf 100644
--- a/NEWS
+++ b/NEWS
@@ -1,613 +1,617 @@
* --export does now only exports rfc2440 compatible keys; the
old behavious is available with --export-all.
Generation of v3 ElGamal (sign and encrypt) keys is not longer
supported.
* Fixed the uncompress bug.
* Rewrote the rndunix module. There are two environment variables
- used for debugging now: GNUPG_RNDUNIX_DBG give the file to write
- debugging information (use "-" for stdout) and if GNUPG_RNDUNIX_DBGALL
- is set, all programs which are only tried are also printed.
-
+ used for debugging now: GNUPG_RNDUNIX_DBG give the file to write
+ debugging information (use "-" for stdout) and if GNUPG_RNDUNIX_DBGALL
+ is set, all programs which are only tried are also printed.
+
+ * New option --escape-from-lines to "dash-escape" "From " lines to
+ prevent mailers to change them to ">From ". This is not enabled by
+ default because it is not in compliace with rfc2440. but you should
+ turn it on.
Noteworthy changes in version 0.4.5
-----------------------------------
* The keyrings and the trustdb is now locked, so that
other GnuPG processes won't damage these files. You
may want to put the option --lock-once into your options file.
* The latest self-signatures are now used; this enables --import
to see updated preferences etc.
* Import of subkeys should now work.
* Random gathering modules may now be loaded as extensions. Add
such a module for most Unices but it is very experimental!
* Brazilian language support.
Noteworthy changes in version 0.4.4
-----------------------------------
* Fixed the way the key expiration time is stored. If you have
an expiration time on your key you should fix it with --edit-key
and the command "expire". I apologize for this inconvenience.
* Add option --charset to support "koi8-r" encoding of user ids.
(Not yet tested).
* Preferences should now work again. You should run
"gpgm --check-trustdb \*" to rebuild all preferences.
* Checking of certificates should now work but this needs a lot
of testing. Key validation values are now cached in the
trustdb; they should be recalculated as needed, but you may
use --check-trustdb or --update-trustdb to do this.
* Spanish translation by Urko Lusa.
* Patch files are from now on signed. See the man page
for the new option --not-dash-escaped.
* New syntax: --edit-key <userID> [<commands>]
If you run it without --batch the commands are executed and then
you are put into normal mode unless you use "quit" or "save" as
one of the commands. When in batch mode, the program quits after
the last command, so you have to use "save" if you did some changes.
It does not yet work completey, but may be used to list so the
keys etc.
Noteworthy changes in version 0.4.3
-----------------------------------
* Fixed the gettext configure bug.
* Kludge for RSA keys: keyid and length of a RSA key are
correctly reported, but you get an error if you try to use
this key (If you do not have the non-US version).
* Experimental support for keyrings stored in a GDBM database.
This is *much* faster than a standard keyring. You will notice
that the import gets slower with time; the reason is that all
new keys are used to verify signatures of previous inserted
keys. Use "--keyring gnupg-gdbm:<name-of-gdbm-file>". This is
not (yet) supported for secret keys.
* A Russian language file in the distribution (alternatives are in
the contrib directory of the FTP servers)
* commandline option processing now works as expected for GNU programs
with the execption that you can't mix options and normal arguments.
* Now --list-key lists all matching keys. This is needed in some
other places too.
Noteworthy changes in version 0.4.2
-----------------------------------
* This is only a snapshot: There are still a few bugs.
* Fixed this huge memory leak.
* Redesigned the trust database: You should run "gpgm --check-trustdb".
New command --update-trustdb, which adds new key from the public
keyring into your trustdb
* Fixed a bug in the armor code, leading to invalid packet errors.
(a workaround for this was to use --no-armor). The shorten line
length (64 instead of 72) fixes a problem with pgp5 and keyservers.
* comment packets are not anymore generated. "--export" filters
them out. One Exception: The comment packets in a secret keyring
are still used because they carry the factorization of the public
prime product.
* --import now only looks for KEYBLOCK headers, so you can now simply
remove the "- " in front of such a header if someone accdently signed
such a message or the keyblock is part of a cleartext signed message.
* --with-colons now lists the key expiration time and not anymore
the valid period.
* Some keyblocks created with old releases have a wrong sequence
of packets, so that the keyservers don't accept these keys.
Simply using "--edit-key" fixes the problem.
* New option --force-v3-sigs to generate signed messages which are
compatible to PGP 5.
* Add some code to support DLD (for non ELF systems) - but this is
not tested because my BSD box is currently broken.
* New command "expire" in the edit-key menu.
Noteworthy changes in version 0.4.1
-----------------------------------
* A secondary key is used when the primary key is specified but cannot
be used for the operation (if it is a sign-only key).
* GNUPG can now handle concatenated armored messages: There is still a
bug if different kinds of messages are mixed.
* Iterated+Salted passphrases now work. If want to be sure that PGP5
is able to handle them you may want to use the options
"--s2k-mode 3 --s2k-cipher-algo cast5 --s2k-digest-algo sha1"
when changing a passphrase.
* doc/OpenPGP talks about OpenPGP compliance, doc/HACKING gives
a few hints about the internal structure.
* Checked gnupg against the August 1998 draft (07) and I believe
it is in compliance with this document (except for one point).
* Fixed some bugs in the import merging code and rewrote some
code for the trustdb.
Noteworthy changes in version 0.4.0
-----------------------------------
* Triple DES is now supported. Michael Roth did this piece of
needed work. We have now all the coded needed to be OpenPGP
compliant.
* Added a simple rpm spec file (see INSTALL).
* detached and armored signatures are now using "PGP SIGNATURE",
except when --rfc1991 is used.
* All times which are not in the yyy-mm-dd format are now printed
in local time.
Noteworthy changes in version 0.3.5
-----------------------------------
* New option --throw-keyid to create anonymous enciphered messages.
If gpg detects such a message it tires all available secret keys
in turn so decode it. This is a gnupg extension and not in OpenPGP
but it has been discussed there and afaik some products use this
scheme too (Suggested by Nimrod Zimmerman).
* Fixed a bug with 5 byte length headers.
* --delete-[secret-]key is now also availabe in gpgm.
* cleartext signatures are not anymore converted to LF only.
* Fixed a trustdb problem. Run "gpgm --check-trustdb" to fix old
trust dbs.
* Building in another directory should now work.
* Weak key detection mechanism (Niklas Hernaeus).
Noteworthy changes in version 0.3.4
-----------------------------------
* New options --comment and --set-filename; see g10/OPTIONS
* yes/no, y/n localized.
* Fixed some bugs.
Noteworthy changes in version 0.3.3
-----------------------------------
* IMPORTANT: I found yet another bug in the way the secret keys
are encrypted - I did it the way pgp 2.x did it, but OpenPGP
and pgp 5.x specifiy another (in some aspects simpler) method.
To convert your secret keys you have to do this:
1. Build the new release but don't install it and keep
a copy of the old program.
2. Disable the network, make sure that you are the only
user, be sure that there are no trojan horses etc ....
3. Use your old gpg (version 0.3.[12]) and set the
passphrases of ALL your secret keys to empty!
(gpg --change-passphrase your-user-id).
4. Save your ownertrusts (see the next point)
5. rm ~/.gnupg/trustd.gpg
6. install the new version of gpg (0.3.3)
7. For every secret key call "gpg --edit-key your-user-id",
enter "passwd" at the prompt, follow the instructions and
change your passward back, enter "save" to store it.
8. Restore the ownertrust (see next point).
* The format of the trust database has changed; you must delete
the old one, so gnupg can create a new one.
IMPORTANT: Use version 0.3.[12] to save your assigned ownertrusts
("gpgm --list-ownertrust >saved-trust"); then build this new version
and restore the ownertrust with this new version
("gpgm --import-ownertrust saved-trust"). Please note that
--list-ownertrust has been renamed to --export-ownertrust in this
release and it does now only export defined ownertrusts.
* The command --edit-key now provides a commandline driven menu
which can be used vor vaious tasks. --sign-key is only an
an alias to --edit-key and maybe removed in future: use the
command "sign" of this new menu - you can select which user ids
you want to sign.
* Alternate user ids can now be created an signed.
* Owner trust values can now be changed with --edit-key (trust)
* GNUPG can now run as a coprocess; this enables sophisticated
frontends. tools/shmtest.c is a simple sample implemenation.
This needs some more work: all tty_xxx() are to be replaced
by cpr_xxx() and some changes in the display logics is needed.
* Removed options --gen-prime and --gen-random.
* Removed option --add-key; use --edit-key instead.
* Removed option --change-passphrase; use --edit-key instead.
* Signatures are now checked even if the output file could not
be created. Command "--verify" tries to find the detached data.
* gpg now disables core dumps.
* compress and symmetric cipher preferences are now used.
Because there is no 3DES yet, this is replaced by Blowfish.
* We have added the Twofish as an experimental cipher algorithm.
Many thanks to Matthew Skala for doing this work.
Twofish is the AES submission from Schneier et al.; see
"www.counterpane.com/twofish.html" for more information.
* Started with a help system: If you enter a question mark at some
prompt; you should get a specific help for this prompt.
* There is no more backup copy of the secret keyring.
* A lot of new bugs. I think this release is not as stable as
the previous one.
Noteworthy changes in version 0.3.2
-----------------------------------
* Fixed some bugs when using --textmode (-seat)
* Now displays the trust status of a positive verified message.
* Keyrings are now scanned in the sequence they are added with
--[secret-]keyring. Note that the default keyring is implictly
added as the very first one unless --no-default-keyring is used.
* Fixed setuid and dlopen bug.
Noteworthy changes in version 0.3.1
-----------------------------------
* Partial headers are now written in the OpenPGP format if
a key in a v4 packet is used.
* Removed some unused options, removed the gnupg.sig stuff.
* Key lookup by name now returns a key which can be used for
the desired action.
* New options --list-ownertrust (gpgm) to make a backup copy
of the ownertrust values you assigned.
* clear signature headers are now in compliance with OpenPGP.
Noteworthy changes in version 0.3.0
-----------------------------------
* New option --emulate-checksum-bug. If your passphrase does not
work anymore, use this option and --change-passphrase to rewrite
your passphrase.
* More complete v4 key support: Preferences and expiration time
is set into the self signature.
* Key generation defaults to DSA/ElGamal keys, so that new keys are
interoperable with pgp5
* DSA key generation is faster and key generation does not anymore
remove entropy from the random generator (the primes are public
parameters, so there is really no need for a cryptographic secure
prime number generator which we had used).
* A complete new structure for representing the key parameters.
* Removed most public key knowledge into the cipher libray.
* Support for dynamic loading of new algorithms.
* Moved tiger to an extension module.
Noteworthy changes in version 0.2.19
------------------------------------
* Replaced /dev/urandom in checks with new tool mk-tdata.
* Some assembler file cleanups; some more functions for the Alpha.
* Tiger has now the OpenPGP assigned number 6. Because the OID has
changed, old signatures using this algorithm can't be verified.
* gnupg now encrypts the compressed packed and not any longer in the
reverse order; anyway it can decrypt both versions. Thanks to Tom
for telling me this (not security related) bug.
* --add-key works and you are now able to generate subkeys.
* It is now possible to generate ElGamal keys in v4 packets to create
valid OpenPGP keys.
* Some new features for better integration into MUAs.
Noteworthy changes in version 0.2.18
------------------------------------
* Splitted cipher/random.c, add new option "--disable-dev-random"
to configure to support the development of a random source for
other systems. Prepared sourcefiles rand-unix.c, rand-w32.c
and rand-dummy.c (which is used to allow compilation on systems
without a random source).
* Fixed a small bug in the key generation (it was possible that 48 bits
of a key were not taken from the random pool)
* Add key generation for DSA and v4 signatures.
* Add a function trap_unaligned(), so that a SIGBUS is issued on
Alphas and not the slow emulation code is used. And success: rmd160
raised a SIGBUS.
* Enhanced the formatting facility of argparse and changed the use of
\r,\v to @ because gettext does not like it.
* New option "--compress-algo 1" to allow the creation of compressed
messages which are readable by PGP and "--print-md" (gpgm) to make
speed measurement easier.
Noteworthy changes in version 0.2.17
------------------------------------
* Comment packets are now of private type 61.
* Passphrase code still used a 160 bit blowfish key, added a
silly workaround. Please change your passphrase again - sorry.
* Conventional encryption now uses a type 3 packet to describe the
used algorithms.
* The new algorithm number for Blowfish is 20, 16 is still used for
encryption only; for signing it is only used when it is in a v3 packet,
so that GNUPG keys are still valid.
Noteworthy changes in version 0.2.16
------------------------------------
* Add experimental support for the TIGER/192 message diigest algorithm.
(But there is only a dummy ASN OID).
* Standard cipher is now Blowfish with 128 bit key in OpenPGP's CFB
mode. I renamed the old cipher to Blowfish160. Because the OpenPGP
group refused to assign me a number for Blowfish160, I have to
drop support for this in the future. You should use
"--change-passphrase" to recode your current passphrase with 128
bit Blowfish.
Noteworthy changes in version 0.2.15
------------------------------------
* Fixed a bug with the old checksum calculation for secret keys.
If you run the program without --batch, a warning does inform
you if your secret key needs to be converted; simply use
--change-passphrase to recalculate the checksum. Please do this
soon, as the compatible mode will be removed sometime in the future.
* CAST5 works (using the PGP's special CFB mode).
* Again somewhat more PGP 5 compatible.
* Some new test cases
Noteworthy changes in version 0.2.14
------------------------------------
* Changed the internal handling of keyrings.
* Add support to list PGP 5 keyrings with supkeys
* Timestamps of signatures are now verified.
* A expiration time can now be specified during key generation.
* Some speedups for Blowfish and SHA-1, rewrote SHA-1 transform.
Reduced the amount of random bytes needed for key generation in
some cases.
Noteworthy changes in version 0.2.13
------------------------------------
* Verify of DSA signatures works.
* Re-implemented the slower random number generator.
Noteworthy changes in version 0.2.12
------------------------------------
* --delete-key checks that there is no secret key. The new
option --delete-secret-key maybe used to delete a secret key.
* "-kv" now works as expected. Options "--list-{keys,sigs]"
and "--check-sigs" are now working.
* New options "--verify" and "--decrypt" to better support integration
into MUAs (partly done for Mutt).
* New option "--with-colons" to make parsing of key lists easier.
Noteworthy changes in version 0.2.11
------------------------------------
* GPG now asks for a recipient's name if option "-r" is not used.
* If there is no good trust path, the program asks whether to use
the public keys anyway.
* "--delete-key" works for public keys. What semantics shall I use
when there is a secret key too? Delete the secret key or leave him
and auto-regenerate the public key, netxt time the secret key is used?
Noteworthy changes in version 0.2.10
------------------------------------
* Code for the alpha is much faster (about 20 times); the data
was misaligned and the kernel traps this, so nearly all time
was used by system to trap the misalignments and to write
syslog messages. Shame on me and thanks to Ralph for
pointing me at this while drinking some beer yesterday.
* Changed some configure options and add an option
--disable-m-guard to remove the memory checking code
and to compile everthing with optimization on.
* New environment variable GNUPGHOME, which can be used to set
another homedir than ~/.gnupg. Changed default homedir for
Windoze version to c:/gnupg.
* Fixed detached signatures; detached PGP signatures caused a SEGV.
* The Windoze version works (as usual w/o a strong RNG).
Noteworthy changes in version 0.2.9
-----------------------------------
* Fixed FreeBSD bug.
* Added a simple man page.
* Switched to automake1.2f and a newer gettext.
Noteworthy changes in version 0.2.8
-----------------------------------
* Changed the name to GNUPG, the binaries are called gpg and gpgm.
You must rename rename the directory "~/.g10" to ~/.gnupg/, rename
{pub,sec}ring.g10 to {pub,sec}ring.gpg, trustdb.g10 to trustdb.gpg
and g10.sig to gnupg.sig.
* New or changed passphrases are now salted.
Noteworthy changes in version 0.2.7
-----------------------------------
* New command "gen-revoke" to create a key revocation certificate.
* New option "homedir" to set the homedir (which defaults to "~/.g10").
This directory is created if it does not exists (only the last
part of the name and not the complete hierarchy)
* Command "import" works. (Try: "finger gcrypt@ftp.guug.de|g10 --import")
* New commands "dearmor/enarmor" for g10maint. These are mainly
used for internal test purposes.
* Option --version now conforming to the GNU standards and lists
the available ciphers, message digests and public key algorithms.
* Assembler code for m68k (not tested).
* "make check" works.
Noteworthy changes in version 0.2.6
-----------------------------------
* Option "--export" works.
Noteworthy changes in version 0.2.5
-----------------------------------
* Added zlib for systems which don't have it.
Use "./configure --with-zlib" to link with the static version.
* Generalized some more functions and rewrote the encoding of
message digests into MPIs.
* Enhanced the checkit script
Noteworthy changes in version 0.2.4
-----------------------------------
* nearly doubled the speed of the ElGamal signature verification.
* backup copies of keyrings are created.
* assembler stuff for Pentium; gives about 15% better perfomance.
* fixed a lot of bugs.
Noteworthy changes in version 0.2.3
-----------------------------------
* Found a bug in the calculation of ELG fingerprints. This is now
fixed, but all existing fingerprints and keyids for ELG keys
are not any more valid.
* armor should now work; including clear signed text.
* moved some options to the new program g10maint
* It's now 64 bit clean and runs fine on an alpha--linux.
* Key generation is much faster now. I fixed this by using not
so strong random number for the primes (this was a bug because the
ElGamal primes are public parameters and it does not make sense
to generate them from strong random). The real secret is the x value
which is still generated from strong (okay: /dev/random) random bits.
* added option "--status-fd": see g10/OPTIONS
* We have secure memeory on systems which support mlock().
It is not complete yet, because we do not have signal handler
which does a cleanup in very case.
We should also check the ulimit for the user in the case
that the admin does not have set a limit on locked pages.
* started with internationalization support.
* The logic to handle the web of trust is now implemented. It is
has some bugs; but I'm going to change the algorithm anyway.
It works by calculating the trustlevel on the fly. It may ask
you to provide trust parameters if the calculated trust probability
is too low. I will write a paper which discusses this new approach.
* a couple of changes to the configure script.
* New option "--quick-random" which uses a much quicker random
number generator. Keys generated while this option is in effect
are flags with "INSECURE!" in the user-id. This is a development
only option.
* Read support for new version packets (OpenPGP).
* Comment packets are now of correct OpenPGP type 16. Old comment
packets written by G10 are detected because they always start with
a hash which is an invalid version byte.
* The string "(INSECURE!)" is appended to a new user-id if this
is generated on a system without a good random number generator.
diff --git a/PROJECTS b/PROJECTS
index d5b1eb123..0ffd0fce1 100644
--- a/PROJECTS
+++ b/PROJECTS
@@ -1,36 +1,36 @@
* Check if an object (a message, detached sign, public key, or whatever)
is signed by definite user, i.e. define user
(userid, or any other unique identification) on command line.
--> NO: Use a script and --status-fd
* Change the internal represention of keyid into a struct which
can also hold the localid and extend the localid to hold information
of the subkey number because two subkeys may have the same keyid.
* signature verification is done duplicated on import: in import.c and
tehn in trustdb.c too. Maybe we can use a flag to skip the actual
verification process (this should work if we use the same keyblock,
but I'm not sure how to accomplish that). Another way is to allow
the import of bogus data and let trustdb mark these keys as invalid;
I see an advantage in this that it may help to prevent a DoS on a
keyserver by sending him a lot of bogus signatures which he has
to check - Needs further investigation.
* abstraction of the MPI
* Add a way to override the current cipher/md implementations
by others (using extensions)
* Not GnuPG replated: What about option completion in bash?
Can "--dump-options" be used for this or should we place the
options in a special ELF segment?
* Split key support (n-out-of-m)
- * Check Berkeley BD - it is in glibc - any licensing problems?
+ * Check Berkeley DB - it is in glibc - any licensing problems?
* add an option to re-create a public key from a secret key; we
can do this in trustdb.c:verify_own_keys.
(special tool?)
diff --git a/README b/README
index e1f9a3723..8e78f46a7 100644
--- a/README
+++ b/README
@@ -1,344 +1,344 @@
-----BEGIN PGP SIGNED MESSAGE-----
GnuPG - The GNU Privacy Guard
-------------------------------
Version 0.4
As you can see from the version number, the program may have some
bugs and some features may not work at all - please report this to
the mailing list.
On a Linux box (version 2.x.x, alpha or x86 CPU) it should
work reliably. You may create your key on such a machine and
use it. Please verify the tar file; there is a PGP and a GnuPG
signature available. My PGP 2 key is well known and published in
the "Global Trust Register for 1998", ISBN 0-9532397-0-5.
I have included my pubring as "g10/pubring.asc", which contains
the key used to make GnuPG signatures:
"pub 1024D/57548DCD 1998-07-07 Werner Koch (gnupg sig) <dd9jn@gnu.org>"
"Key fingerprint = 6BD9 050F D8FC 941B 4341 2DCC 68B7 AB89 5754 8DCD"
Old version of gnupg are signed with this key:
"pub 1312G/FF3EAA0B 1998-02-09 Werner Koch <wk@isil.d.shuttle.de>"
"Key fingerprint = 8489 6CD0 1851 0E33 45DA CD67 036F 11B8 FF3E AA0B"
My usual key is now:
"pub 1024D/621CC013 1998-07-07 Werner Koch <werner.koch@guug.de>"
"Key fingerprint = ECAF 7590 EB34 43B5 C7CF 3ACB 6C7E E1B8 621C C013"
You may add it to your GnuPG pubring and use it in the future to
verify new releases. Because you verified this README file and
_checked_that_it_is_really_my PGP2 key 0C9857A5, you can be sure
that the above fingerprints are correct.
Please subscribe to g10@net.lut.ac.uk by sending a mail with
the word "subscribe" in the body to "g10-request@net.lut.ac.uk".
This mailing is closed (only subscribers can post) to avoid spam.
See the file COPYING for copyright and warranty information.
Due to the fact that GnuPG does not use use any patented algorithm,
it cannot be compatible with old PGP versions, because those use
IDEA (which is patented worldwide) and RSA (which is patented in
the United States until Sep 20, 2000).
GnuPG is in compliance with RFC2440 (OpenPGP), see doc/OpenPGP for
deatils.
The default algorithms are now DSA and ELGamal. ELGamal for signing
is still available, but due to the larger size of such signatures it
is depreciated (Please note that the GnuPG implementation of ElGamal
signatures is *not* insecure). Symmetric algorithms are: 3DES, Blowfish
and CAST5, Digest algorithms are MD5, RIPEMD160, SHA1 and TIGER/192.
Installation
------------
Please read the file INSTALL!
Here is a quick summary:
1) "./configure"
2) "make"
3) "make install"
4) You end up with a binary "gpg" in /usr/local/bin
5) Optional, but suggested: install the program "gpg" as suid root.
Key Generation
--------------
gpg --gen-key
This asks some questions and then starts key generation. To create
good random numbers for prime number generation, it uses a /dev/random
which will only emit bytes if the kernel can gather enough entropy.
If you see no progress, you should start some other activities such
as mouse moves, "find /" or using the keyboard (in another window).
Because we have no hardware device to generate randomness we have to
use this method.
You should make a revocation certificate in case someone gets
knowledge of your secret key or you forgot your passphrase:
gpg --gen-revoke your_user_id
Run this command and store it away; output is always ASCII armored,
so that you can print it and (hopefully never) re-create it if
your electronic media fails.
If you decided to create a DSA key, you should add an ElGamal
for encryption:
gpg --add-key user_id_of_your_key
and follow the displayed instructions (select "ElGamal using v4 packets").
You can sign a key with this command:
gpg --sign-key Donald
This let you sign the key of "Donald" with your default userid.
gpg --sign-key -u Karl -u Joe Donald
This let you sign the key of of "Donald" with the userids of "Karl"
and "Joe".
All existing signatures are checked; if some are invalid, a menu is
offered to delete some of them, and then you are asked for every user
whether you want to sign this key.
You may remove a signature at any time using the option "--edit-sig",
which asks for the sigs to remove. Self-signatures are not removable.
Sign
----
gpg -s file
This creates a file file.gpg which is compressed and has a signature
attached.
gpg -sa file
Same as above, but file.gpg is ascii armored.
gpg -s -o out file
Creates a signature of file, but writes the output to the file "out".
If you use the option "--rfc1991", gnupg tries to me more compatible
to RFC1991 (pgp 2.x).
Encrypt
-------
gpg -e -r heine file
This encrypts files with the public key of "heine" and writes it
to "file.gpg"
echo "hallo" | gpg -ea -r heine | mail heine
Ditto, but encrypts "hallo\n" and mails it as ascii armored message.
Sign and Encrypt
----------------
gpg -se -r heine file
This encrypts files with the public key of "heine" and writes it
to "file.gpg" after signing it with the default user id.
gpg -se -r heine -u Suttner file
Ditto, but sign the file with the user id "Suttner"
Keyring Management
------------------
To export your complete keyring(s) do this:
gpg --export
To export only some user ids do this:
gpg --export userids
Use "-a" or "--armor" to create ASCII armored output.
Importing keys is done with the option, you guessed it, "--import":
gpg --import [filenames]
New keys are appended to the default keyring and already existing
keys are merged. Keys without a self-signature are ignored.
How to Specify a UserID
-----------------------
There are several ways to specify a userID, here are some examples:
* Only by the short keyid (prepend a zero if it begins with A..F):
"234567C4"
"0F34E556E"
"01347A56A"
"0xAB123456
* By a complete keyid:
"234AABBCC34567C4"
"0F323456784E56EAB"
"01AB3FED1347A5612"
"0x234AABBCC34567C4"
* By a fingerprint:
"1234343434343434C434343434343434"
"123434343434343C3434343434343734349A3434"
"0E12343434343434343434EAB3484343434343434"
The first one is MD5 the others are ripemd160 or sha1.
* By an exact string (not yet implemented):
"=Heinrich Heine <heinrichh@uni-duesseldorf.de>"
* By an email address:
"<heinrichh@uni-duesseldorf.de>"
This can be used by a keyserver instead of a substring to
find this key faster.
* By the Local ID (from the trustdb):
"#34"
This can be used by a MUA to specify an exact key after selecting
a key from GnuPG (by the use of a special option or an extra utility)
* Or by the usual substring:
"Heine"
"*Heine"
The '*' indicates substring search explicitly.
Batch mode
----------
If you use the option "--batch", GnuPG runs in non-interactive mode and
never prompts for input data. This does not even allow entering the
passphrase; until we have a better solution (something like ssh-agent),
you can use the option "--passhrase-fd n", which works like PGPs
PGPPASSFD.
Batch mode also causes GnuPG to terminate as soon as a BAD signature is
detected.
Exit status
-----------
GnuPG returns with an exit status of 1 if in batch mode and a bad signature
has been detected or 2 or higher for all other errors. You should parse
stderr or the output of the fd specified with --status-fd to get detailed
information about the errors.
Esoteric commands
-----------------
gpg --list-packets datafile
Use this to list the contents of a data file. If the file is encrypted
you are asked for the passphrase, so that GnuPG is able to look at the
inner structure of a encrypted packet.
gpgm --list-trustdb
List the contents of the trustdb in a human readable format
gpgm --list-trustdb <usernames>
List the tree of certificates for the given usernames
gpgm --list-trust-path depth username
List the possible trust paths for the given username, up to the specified
depth. If depth is negative, duplicate introducers are not listed,
because those would increase the trust probability only minimally.
(you must use the special option "--" to stop option parsing when
using a negative number). This option may create new entries in the
trustdb.
gpgm --print-mds filenames
List all available message digest values for the fiven filenames
For more options/commands see the file g10/OPTIONS, or use "gpg --help"
Debug Flags
-----------
Use the option "--debug n" to output debug information. This option
can be used multiple times, all values are ORed; n maybe prefixed with
0x to use hex-values.
value used for
----- ----------------------------------------------
1 packet reading/writing
2 MPI details
4 ciphers and primes (may reveal sensitive data)
8 iobuf filter functions
16 iobuf stuff
32 memory allocation stuff
64 caching
128 show memory statistics at exit
256 trust verification stuff
Other Notes
-----------
This is work in progress, so you may find duplicated code fragments,
ugly data structures, weird usage of filenames and other things.
- The primary FTP site is "ftp://ftp.guug.de/pub/gcrypt/"
- The primary WWW page is "http://www.d.shuttle.de/isil/gnupg/"
+ The primary FTP site is "ftp://ftp.gnupg.org/pub/gcrypt/"
+ The primary WWW page is "http://www.gnupg.org"
If you like, send your keys to <gnupg-keys@isil.d.shuttle.de>; use
"gpg --export --armor | mail gnupg-keys@isil.d.shuttle.de" to do this.
Please direct bug reports to <gnupg-bugs@gnu.org> or better
post them to the mailing list <g10@net.lut.ac.uk> (this is a closed list,
please subscribe before posting, see above (~line 33)).
-----BEGIN PGP SIGNATURE-----
Version: GnuPG v0.4.4 (GNU/Linux)
Comment: For info finger gcrypt@ftp.guug.de
iQB1AwUBNlXAUh0Z9MEMmFelAQFmhwL/RfW9WxAMTh/edDy0yGTJjDgo7d/Kfmtq
8C0LJ4b2M0py1ctW6jZyiQsYtvkrttKiTYXGtRoIzVFWX2hqABKPCTHzOeXQEOSu
ro5fnRwsuj9cRxhH8lpN+diY+m1E5Fu3
=sciv
-----END PGP SIGNATURE-----
diff --git a/THANKS b/THANKS
index 460b39780..d0f66e107 100644
--- a/THANKS
+++ b/THANKS
@@ -1,89 +1,90 @@
GnuPG was originally written by Werner Koch. Other people contributed by
reporting problems, suggesting various improvements or submitting actual
code. Here is a list of those people. Help me keep it complete and free of
errors.
Anand Kumria wildfire@progsoc.uts.edu.au
Ariel T Glenn ariel@columbia.edu
Bryan Fullerton bryanf@samurai.com
Brian Moore bem@cmc.net
Brian Warner warner@lothar.com
Caskey L. Dickson caskey@technocage.com
Cees van de Griend cees-list@griend.xs4all.nl
Charles Levert charles@comm.polymtl.ca
Christian von Roques roques@pond.sub.org
Christopher Oliver oliver@fritz.traverse.net
Daniel Eisenbud eisenbud@cs.swarthmore.edu
David Ellement ellement@sdd.hp.com
Detlef Lannert lannert@lannert.rz.uni-duesseldorf.de
Dirk Lattermann dlatt@t-online.de
Ed Boraas ecxjo@esperanto.org
Ernst Molitor ernst.molitor@uni-bonn.de
Fabio Coatti cova@felix.unife.it
Felix von Leitner leitner@amdiv.de
Frank Heckenbach heckenb@mi.uni-erlangen.de
Gaël Quéri gqueri@mail.dotcom.fr
Greg Louis glouis@dynamicro.on.ca
Greg Troxel gdt@ir.bbn.com
Gregory Steuck steuck@iname.com
Geoff Keating geoffk@ozemail.com.au
Hendrik Buschkamp buschkamp@rheumanet.org
Holger Schurig holger@d.om.org
Hugh Daniel hugh@toad.com
Ian McKellar imckellar@harvestroad.com.au
James Troup james@nocrew.org
Jean-loup Gailly gzip@prep.ai.mit.edu
Jens Bachem bachem@rrz.uni-koeln.de
John A. Martin jam@jamux.com
Johnny Teveßen j.tevessen@gmx.de
Jörg Schilling schilling@fokus.gmd.de
Jun Kuriyama kuriyama@sky.rim.or.jp
Karl Fogel kfogel@guanabana.onshore.com
Karsten Thygesen karthy@kom.auc.dk
Kazu Yamamoto kazu@iijlab.net
Lars Kellogg-Stedman lars@bu.edu
Marco d'Itri md@linux.it
Mark Adler madler@alumni.caltech.edu
Markus Friedl Markus.Friedl@informatik.uni-erlangen.de
Martin Schulte schulte@thp.uni-koeln.de
Matthew Skala mskala@ansuz.sooke.bc.ca
Max Valianskiy maxcom@maxcom.ml.org
Michael Roth mroth@nessie.de
Michael Sobolev mss@despair.transas.com
Nicolas Graner Nicolas.Graner@cri.u-psud.fr
Niklas Hernaeus [Please don't spam him]
Nimrod Zimerman zimerman@forfree.at
N J Doye nic@niss.ac.uk
Oskari Jääskeläinen f33003a@cc.hut.fi
Paul D. Smith psmith@baynetworks.com
Peter Gutmann pgut001@cs.auckland.ac.nz
QingLong qinglong@bolizm.ihep.su
Ralph Gillen gillen@theochem.uni-duesseldorf.de
+Reuben Sumner rasumner@wisdom.weizmann.ac.il
Roddy Strachan roddy@satlink.com.au
Roland Rosenfeld roland@spinnaker.rhein.de
Ross Golder rossigee@bigfoot.com
Serge Munhoven munhoven@mema.ucl.ac.be
SL Baur steve@xemacs.org
Stefan Karrmann S.Karrmann@gmx.net
Steffen Ullrich ccrlphr@xensei.com
Steffen Zahn zahn@berlin.snafu.de
Susanne Schultz schultz@hsp.de
Thiago Jung Bauermann jungmann@usa.net
Thomas Roessler roessler@guug.de
Tom Spindler dogcow@home.merit.edu
Tom Zerucha tzeruch@ceddec.com
Tomas Fasth tomas.fasth@twinspot.net
Thomas Mikkelsen tbm@image.dk
Ulf Möller 3umoelle@informatik.uni-hamburg.de
Urko Lusa ulusa@lacueva.ddns.org
Walter Koch walterk@ddorf.rhein-ruhr.de
Werner Koch werner.koch@guug.de
Wim Vandeputte bunbun@reptile.rug.ac.be
nbecker@hns.com
Thanks to the German Unix User Group for providing FTP space,
Martin Hamilton for hosting the mailing list and hsp for
hosting gnupg.org.
Many thanks to my wife Gerlinde for having so much patience with
me while hacking late in the evening.
diff --git a/TODO b/TODO
index 168c8b7f1..96dcaab23 100644
--- a/TODO
+++ b/TODO
@@ -1,47 +1,49 @@
* Check revocation and expire stuff. PLEASE: THIS MUST BE TESTED!
+ * Escape "From "
+
* Check calculation of key validity. PLEASE: IT IS IMPORTED THAT
THIS GET TESTED.
* preferences of hash algorithms are not yet used.
* I noticed, that we sometimes have only 3 items in a trustrecord, but
a next pointer ro more records - check wehther the reuse code really
works. Maybe this is the reason for the "Hmmm public key lost"
* clearsig: keep lineendings as they are. Remember that trailings
blanks are not hashed.
* should we flush the getkey.c caches while doing an import?
* We need a maintainence pass over the trustdb which flags
signatures as expired if the key used to make the signature has
expired. Maybe it is a good idea to store the exiration time
in the key record of the trustdb.
* write a tool to extract selected keys from a file.
* new menu to delete signatures and list signature in menu
* Replace the SIGUSR1 stuff by semaphores to avoid loss of a signal.
or use POSIX.4 realtime signals.
* add test cases for invalid data (scrambled armor or other random data)
* rewrite --list-packets or put it into another tool.
* Burn the buffers used by fopen(), or use read(2). Does this
really make sense?
* Change the buffering to a mbuf like scheme? Need it for PSST anyway;
see Michael's proposal.
* add checking of armor trailers
* remove all "Fixmes" ;-)
* change the fake_data stuff to mpi_set_opaque
* Replace Blowfish by Twofish
* Work on the library
diff --git a/doc/gpg.1pod b/doc/gpg.1pod
index 6d4bcaa7c..533156cd8 100644
--- a/doc/gpg.1pod
+++ b/doc/gpg.1pod
@@ -1,538 +1,546 @@
=head1 NAME
gpg, gpgm - GNU Privacy Guard
=head1 SYNOPSIS
B<gpg> [--homedir name] [--options file] [options] command [args]
B<gpgm> [--homedir name] [--options file] [options] command [args]
=head1 DESCRIPTION
B<gpg> is the main program for the GnuPG system. B<gpgm> is a maintenance
tool which has some commands B<gpg> does not have; it is there because
it does not handle sensitive data and therefore has no need to allocate
secure memory.
=head1 COMMANDS
B<gpg> recognizes these commands:
B<-s>, B<--sign>
Make a signature. This option may be combined
with B<--encrypt>.
B<--clearsign>
Make a clear text signature.
B<-b>, B<--detach-sign>
Make a detached signature.
B<-e>, B<--encrypt>
Encrypt data. This option may be combined with B<--sign>.
B<-c>, B<--symmetric>
Encrypt with symmetric cipher only
This command asks for a passphrase.
B<--store>
store only (make a simple RFC1991 packet).
B<--decrypt> [I<file>]
Decrypt file (or stdin if no file is specified) and
write it to stdout (or the file specified with
B<--output>). If the decrypted file is signed, the
signature is also verified. This command differs
from the default operation, as it never writes to the
filename which is included in the file and it
rejects files which don't begin with an encrypted
message.
B<--verify> [[I<sigfile>] {I<signed-files>}]
Assume that I<filename> is a signature and verify it
without generating any output. With no arguments,
the signature packet is read from stdin (it may be a
detached signature when not used in batch mode). If
only a sigfile is given, it may be a complete
signature or a detached signature, in which case
the signed stuff is expected in a file without the
I<.sig> or I<.asc> extension (if such a file does
not exist it is expected at stdin - use B<-> as
filename to force a read from stdin). With more than
1 argument, the first should be a detached signature
and the remaining files are the signed stuff.
B<-k> [I<username>] [I<keyring>]
Kludge to be somewhat compatible with PGP.
Without arguments, all public keyrings are listed.
With one argument, only I<keyring> is listed.
Special combinations are also allowed, but it may
give strange results when combined with more options.
B<-kv> Same as B<-k>
B<-kvv> List the signatures with every key.
B<-kvvv> Additionally check all signatures.
B<-kvc> List fingerprints
B<-kvvc> List fingerprints and signatures
B<--list-keys> [I<names>]
List all keys from the public keyrings, or just the
ones given on the command line.
B<--list-secret-keys> [I<names>]
List all keys from the secret keyrings, or just the
ones given on the command line.
B<--list-sigs> [I<names>]
Same as B<--list-keys>, but the signatures are listed
too.
B<--check-sigs> [I<names>]
Same as B<--list-sigs>, but the signatures are verified.
B<--fingerprint> [I<names>]
List all keys with their fingerprints. This is the
same output as B<list-keys> but with the additional output
of a line with the fingerprint. May also be combined
with B<--list-sigs> or B<--check-sigs>.
B<--list-packets>
List only the sequence of packets. This is mainly
useful for debugging.
B<--gen-key>
Generate a new key pair. This command can only be
used interactive.
B<--edit-key> I<name>
Present a menu which enables you to do all key
related tasks:
B<sign>
Make a signature on key of user I<name>.
If the key is not yet signed by the default
user (or the users given with B<-u>), the
program displays the information of the key
again, together with its fingerprint and
asks whether it should be signed. This
question is repeated for all users specified
with B<-u>.
B<trust>
Change the owner trust value. This updates the
trust-db immediately and no save is required.
B<adduid>
Create an alternate user id.
B<deluid>
Delete an user id.
B<addkey>
Add a subkey to this key.
B<delkey>
Remove a subkey.
B<expire>
Change the key expiration time. If a key is
select, the time of this key will be changed.
With no selection the key expiration of the
primary key is changed.
B<passwd>
Change the passphrase of the secret key.
B<uid> I<n>
Toggle selection of user id with index I<n>.
Use 0 to deselect all.
B<key> I<n>
Toggle selection of subkey with index I<n>.
Use 0 to deselect all.
B<check>
Check all selected user ids.
B<pref>
List preferences.
B<toggle>
Toggle between public and secret key listing.
B<save>
Save all changes to the key rings and quit.
B<quit>
Quit the program without updating the
key rings.
The listing shows you the key with its secondary
keys and all user ids. Selected keys or user ids
indicated by an asterisk. The trust value is
displayed with the primary key: The first one is the
assigned owner trust and the second the calculated
trust value; letters are used for the values:
B<-> No ownertrust assigned / not yet calculated.
B<e> Trust calculation has failed.
B<q> Not enough information for calculation.
B<n> Never trust this key.
B<m> Marginally trusted.
B<f> Fully trusted.
B<u> Ultimately trusted
B<--delete-key>
Remove key from the public keyring
B<--delete-secret-key>
Remove key from the secret and public keyring
B<--gen-revoke>
Generate a revocation certificate.
B<--export> [I<names>]
Either export all keys from all keyrings (default
keyrings and those registered via option B<--keyring>),
or if at least one name is given, those of the given
name. The new keyring is written to F<stdout> or to
the file given with option "output". Use together
with B<-a> to mail those keys.
B<--export-all> [I<names>]
Same as B<--export> but does also export keys which
are not compatible to OpenPGP.
B<--export-secret-keys> [I<names>
Same as B<--export>, but does export the secret keys.
This is normally not very useful.
B<--import>, B<--fast-import>
Import/merge keys. The fast version does not build
the trustdb; this can be deon at anytime with the
command B<--update-trustdb>.
B<--export-ownertrust>
List the assigned ownertrust values in ascii format
for backup purposes [B<gpgm> only].
B<--import-ownertrust> [I<filename>]
Update the trustdb with the ownertrust values stored
in I<filename> (or stdin if not given); existing
values will be overwritten. [B<gpgm> only].
=head1 OPTIONS
Long options can be put in an options file (default F<~/.gnupg/options>);
do not write the 2 dashes, but simply the name of the option and any
arguments if required. Lines with a hash as the first non-white-space
character are ignored. Commands may be put in this file too, but that
does not make sense.
B<gpg> recognizes these options:
B<-a>, B<--armor>
Create ASCII armored output.
B<-o> I<file>, B<--output> I<file>
Write output to I<file>.
B<-u> I<name>, B<--local-user> I<name>
Use I<name> as the user-id to sign.
This option is silently ignored for the list commands,
so that it can be used in an options file.
B<--default-key> I<name>
Use I<name> as default user-id for signatures. If this
is not used the default user-id is the first user-id
from the secret keyring.
B<--trusted-key> I<keyid>
Assume that the key with the I<keyid> (which must be
a full (8 byte) keyid) is as trustworthy as one of
your own secret keys. This may be used to make keys
valid which are not directly ceritified by you but
by a CA you trust. The advantage of this option is
that it shortens the path of certification.
You may also use this option to skip the verification
of your own secret keys which is normally done every
time GnuPG starts up: Use for I<keyid> the one of
your key.
B<-r> I<name>, B<--remote-user> I<name>
Use I<name> as the user-id for encryption.
This option is silently ignored for the list commands,
so that it can be used in an options file.
B<-v>, B<--verbose>
Give more information during processing. If used
twice, the input data is listed in detail.
B<-q>, B<--quiet>
Be somewhat more quiet in some cases.
B<-z> I<n>
Set compress level to I<n>. A value of 0 for I<n>
disables compression. Default is to use the default
compression level of zlib (which is 6).
B<-t>, B<--textmode>
Use canonical text mode. If B<-t> (but not
B<--textmode>) is used together with armoring
and signing, this enables clearsigned messages.
This kludge is needed for PGP compatibility;
normally you would use B<--sign> or B<--clearsign>
to selected the type os signatures.
B<-n>, B<--dry-run>
Don't make any changes (not yet implemented).
B<--batch>
Batch mode; never ask, do not allow interactive
commands.
B<--no-batch>
Disable batch mode; this may be used if B<batch>
is used in the options file.
B<--yes>
Assume "yes" on most questions.
B<--no>
Assume "no" on most questions.
B<--keyring> I<file>
Add I<file> to the list of keyrings.
If I<file> begins with a tilde and a slash, these
are replaced by the HOME directory. If the filename
does not contain a slash, it is assumed to be in the
home-directory (F<~/.gnupg> if B<--homedir>) is not used.
The filename may be prefixed with a scheme:
"gnupg-ring:" is the default one.
"gnupg-gdbm:" may be used for a GDBM ring.
B<--secret-keyring> I<file>
Same as B<--keyring> but for secret keyrings.
B<--homedir> I<dir>
Set the name of the home directory to I<dir>. If this
option is not used it defaults to F<~/.gnupg>. It does
not make sense to use this in a options file. This
also overrides the environment variable C<GNUPGHOME>.
B<--charset> I<name>
Set the name of the native character set. This is used
to convert some strings to proper UTF-8 encoding.
Valid values for I<name> are:
B<iso-8859-1> This is the default.
B<koi8-r> The usual Russian set (rfc1489).
B<--options> I<file>
Read options from I<file> and do not try to read
them from the default options file in the homedir
(see B<--homedir>). This option is ignored when used
in an options file.
B<--no-options>
Shortcut for B<--options> I</dev/null>. This option is
detected before an attempt to open an option file.
B<--load-extension> I<modulename>
Load an extension module. If I<modulename> does not
contain a slash it is searched in B</usr/local/lib/gnupg>
See the manual for more information about extensions.
B<--debug> I<flags>
Set debugging flags. All flags are or-ed and I<flags> may
be given in C syntax (e.g. 0x0042).
B<--debug-all>
Set all useful debugging flags.
B<--status-fd> I<n>
Write special status strings to the file descriptor I<n>.
B<--no-comment>
Do not write comment packets. This option affects only
the generation of secret keys. Output of option packets
is disabled since version 0.4.2.
B<--comment> I<string>
Use I<string> as comment string in clear text signatures.
B<--set-filename> I<string>
Use I<string> as the name of file which is stored in
messages.
B<--completes-needed> I<n>
Number of completely trusted users to introduce a new
key signator (defaults to 1).
B<--marginals-needed> I<n>
Number of marginally trusted users to introduce a new
key signator (defaults to 3)
B<--max-cert-depth> I<n>
Maximum depth of a certification chain (default is 5).
B<--cipher-algo> I<name>
Use I<name> as cipher algorithm. Running the program
with the command B<--version> yields a list of supported
algorithms. If this is not used the cipher algorithm is
selected from the preferences stored with the key.
B<--digest-algo> I<name>
Use I<name> as message digest algorithm. Running the
program with the command B<--version> yields a list of
supported algorithms. Please note that using this
option may violate the OpenPGP requirement, that a
160 bit hash is to be used for DSA.
B<--s2k-cipher-algo> I<name>
Use I<name> as the cipher algorithm used to protect secret
keys. The default cipher is BLOWFISH. This cipher is
also used for conventional encryption if B<--cipher-algo>
is not given.
B<--s2k-digest-algo> I<name>
Use I<name> as the digest algorithm used to mangle the
passphrases. The default algorithm is RIPE-MD-160.
This digest algorithm is also used for conventional
encryption if B<--digest-algo> is not given.
B<--s2k-mode> I<number>
Selects how passphrases are mangled: A number of I<0>
uses the plain passphrase (which is not recommended),
a I<1> (default) adds a salt to the passphrase and
I<3> interates the whole process a couple of times.
Unless -B<--rfc1991> is used, this mode is also used
for conventional encryption.
B<--compress-algo> I<number>
Use compress algorithm I<number>. Default is I<2> which is
RFC1950 compression; you may use I<1> to use the old zlib
version which is used by PGP. This is only used for
new messages. The default algorithm may give better
results because the window size is not limited to 8K.
If this is not used the OpenPGP behaviour is used; i.e.
the compression algorith is selected from the preferences.
B<--digest-algo> I<name>
Use I<name> as message digest algorithm. Running the
program with the command B<--version> yields a list of
supported algorithms.
B<--throw-keyid>
Do not put the keyid into encrypted packets. This option
hides the receiver of the message and is a countermeasure
against traffic analysis. It may slow down the decryption
process because all available secret keys are tried.
B<--not-dash-escaped>
This option changes the behaviour of cleartext signature
so that they can be used for patch files. You should not
send such an armored file via email because all spaces
and line endings are hashed too. You can not use this
option for data which has 5 dashes somewhere at the
beginning of a line - patch files don't have this.
A special armor header line tells GnuPG about this
cleartext signature framework.
+B<--escape-from-lines>
+ Because some mailers change lines starting with "From "
+ to ">From " it is good to handle such lines in a special
+ way when creating cleartext signatures; all other PGP
+ versions do it this way too. Because this would violate
+ rfc2440, this option is not enabled per default.
+
B<--passphrase-fd> I<n>
Read the passphrase from file descriptor I<n>. If you use
0 for I<n>, the passphrase will be read from stdin. This
can only be used if only one passphrase is supplied.
B<Don't use this option if you can avoid it>
B<--rfc1991>
Try to be more RFC1991 (PGP 2.x) compliant.
B<--force-v3-sigs>
OpenPGP states that a implemenation should generate
v4 signatures but PGP 5.x does only recognize such
signatures on key material. This options forces
v3 signatures for signatures on data.
B<--lock-once>
Lock the file the first time a lock is requested
and do not release the lock until the process
terminates.
B<--no-verbose>
Reset verbose level to 0.
B<--no-greeting>
Suppress the initial copyright message but do not
enter batch mode.
B<--no-armor>
Assume the input data is not in ASCII armored format.
B<--no-default-keyring>
Do not add the default keyrings to the list of
keyrings.
B<--skip-verify>
Skip the signature verification step. This may be
used to make the encryption faster if the signature
verification is not needed.
B<--version>
Print version information along with a list
of supported algorithms.
B<--with-colons>
Print key listings delimited by colons.
B<--warranty>
Print warranty information.
B<-h>, B<--help>
Print usage information.
=head1 RETURN VALUE
The Program returns 0 if everything was fine, 1 if at least
a signature was bad and other errorcode for fatal errors.
=head1 EXAMPLES
-se -r Bob [file] sign and encrypt for user Bob
-sat [file] make a clear text signature
-sb [file] make a detached signature
-k [userid] show keys
-kc [userid] show fingerprint
=head1 ENVIRONMENT
C<HOME> Used to locate the default home directory.
C<GNUPGHOME> If set directory used instead of F<~/.gnupg>.
=head1 FILES
F<~/.gnupg/secring.gpg> The secret keyring
F<~/.gnupg/secring.gpg.lock> and the lock file
F<~/.gnupg/pubring.gpg> The public keyring
F<~/.gnupg/pubring.gpg.lock> and the lock file
F<~/.gnupg/trustdb.gpg> The trust database
F<~/.gnupg/trustdb.gpg.lock> and the lock file
F<~/.gnupg/options> May contain options
+F</usr[/local]/share/gnupg/options.skel> Skeleton file
F</usr[/local]/lib/gnupg/> Default location for extensions
=head1 SEE ALSO
gpg(1) gpgm(1)
=head1 WARNINGS
Use a B<good> password for your user account and a B<good> passphrase
to protect your secret key. This passphrase is the weakest part of the
whole system. Programs to do dictionary attacks on your secret keyring
are very easy to write and so you should protect your B<~/.gnupg/>
directory very good.
Keep in mind that, if this program is used over a network (telnet), it
is B<very> easy to spy out your passphrase!
=head1 BUGS
On many systems this program should be installed as setuid(root); this
is necessary to lock some pages of memory. If you get no warning message
about insecure memory your OS kernel supports locking without being root;
setuid is dropped as soon as this memory is allocated.
diff --git a/g10/ChangeLog b/g10/ChangeLog
index 77990ae6d..b2ccffac4 100644
--- a/g10/ChangeLog
+++ b/g10/ChangeLog
@@ -1,1405 +1,1423 @@
+Thu Dec 17 18:31:15 CET 1998 Werner Koch <wk@isil.d.shuttle.de>
+
+ * misc.c (trap_unaligned): Only for glibc 1
+
+ * sign.c (write_dash_escaped): Now escapes "From " lines
+ * g10.c: New option --escape-from-lines
+
+ * trustdb.c (sort_tsl_list): New
+ (list_trust_path): Now prints sorted list.
+ (enum_cert_paths): Likewise.
+ (enum_cert_paths_print): New.
+ (print_paths): New printing format.
+ * pkclist.c (add_ownertrust): New arg quit.
+ (edit_ownertrust): New quit selection and does not query
+ the recipients ownertrust anymore.
+ (add_ownertrust): Print the ceritficate path.
+
+
Mon Dec 14 21:18:49 CET 1998 Werner Koch <wk@isil.d.shuttle.de>
* parse-packet.c (parse_signature): Now checks for critical bit
(parse_sig_subpkt): Splitted.
(parse_one_sig_subpkt): New.
* sig-check.c (do_check): handle critical bit.
Sun Dec 13 14:10:56 CET 1998 Werner Koch <wk@isil.d.shuttle.de>
* pcklist.c (select_algo_from_prefs): Preferences should
now work (lost the != ? )
Thu Dec 10 20:15:36 CET 1998 Werner Koch <wk@isil.d.shuttle.de>
* ringedit.c (gdbm_store): Fix for inserts
* g10.c (main): New option --export-all
* export.c (export_pubkeys): New arg.
(do_export): Now may skip old keys.
* status.c: Minor patches for Sun's cc
* keygen.c (ask_algo): Disabled v3 ElGamal choice, rearranged
the numbers. Add a warning question when a sign+encrypt key
is selected.
* g10.c (do_not_use_RSA): Removed.
* misc.c (print_pubkey_algo_note): New as replacement for the
do_not_use_RSA() and chnaged all callers.
(print_cipher_algo_note): New.
(print_hash_algo_note): New.
* cipher.c (write_header): Add a call to print_cipher_algo_note.
* seckey-cert.c (protect_secret_key): Ditto
* sign.c (do_sign): Add a call to print_digest_algo_note.
* getkey.c (get_long_user_id_string): New.
* mainproc.c (check_sig_and_print): Changed the format of the
status output.
* encrypt.c (write_pubkey_enc_from_list): print used symmetric cipher.
* pkclist.c (do_we_trust): Changed a message.
Wed Dec 9 13:41:06 CET 1998 Werner Koch <wk@isil.d.shuttle.de>
* misc.c (trap_unaligned) [ALPHA]: Only if UAC_SIGBUS is defined.
* sign.c (write_dash_escaped): Add the forgotten patch by Brian Moore.
* compress.c (do_uncompress): Fixed the inflating bug.
Tue Dec 8 13:15:16 CET 1998 Werner Koch <wk@isil.d.shuttle.de>
* trustdb.c (upd_uid_record): Now uses the newest self-signature
(insert_trust_record): Now calls update with recheck set to true.
(register_trusted_key): New.
(verify_own_keys): Enhanced by list of trusted keys.
* g10.c (main): Print a warning when a devel version is used.
(main): New option --trusted-key
* import.c (merge_blocks): Fixed merging of new user ids and
added merging of subkeys.
(append_uid): Ditto.
(merge_keysig): New.
(append_key): New.
* getkey.c (merge_one_pk_and_selfsig): Get the expiration time
from the newest self-signature.
(merge_keys_and_selfsig): Ditto.
* free-packet.c (cmp_secret_key): New.
Fri Nov 27 21:37:41 CET 1998 Werner Koch <wk@isil.d.shuttle.de>
* g10.c: New option --lock-once
* tdbio.c (open_db): Add an atexit
(cleanup): New.
(tdbio_sync): Add locking.
(tdbio_end_transaction): Ditto.
(put_record_into_cache): Ditto.
* ringedit.c (keyring_copy): Ditto.
(cleanup): New.
(add_keyblock_resource): Add an atexit.
Fri Nov 27 15:30:24 CET 1998 Werner Koch <wk@isil.d.shuttle.de>
* armor.c (find_header): Another fix for clearsigs.
Fri Nov 27 12:39:29 CET 1998 Werner Koch <wk@isil.d.shuttle.de>
* status.c (display_help): Removed.
* helptext.c: New and removed the N_() from all cpr_gets.
Fri Nov 20 16:54:52 1998 Werner Koch (wk@isil.d.shuttle.de)
* g10.c (main): New option --not-dash-escaped
* sign.c (write_dashed_escaped): Ditto.
* armor.c (find_header): Support for NotDashEscaped header.
* getkey.c: print "disabled cache.." only if verbose is used.
Thu Nov 19 07:17:31 1998 Werner Koch <werner.koch@guug.de>
* parse-packet.c (dump_sig_subpkt): Fixed expire listing
* getkey.c (merge_keys_and_selfsig): Fixed expire calculation.
(merge_one_pk_and_selfsig): Ditto.
* keyedit.c (menu_expire). Ditto.
* keygen.c (keygen_add_key_expire): Ditto.
(ask_expire_interval): New and changed all local function to use
this instead.
(keygen_add_key_expire): Opaque should now be a public key;
changed all callers.
* parse.packet.c (parse): use skip_rest to skip packets.
* keyedit.c (keyedit_menu): New arg for cmdline cmds.
Wed Nov 18 20:33:50 1998 Werner Koch (wk@isil.d.shuttle.de)
* trustdb.c (check_trustdb): Now rechecks all gived userids.
(collect_paths): Some fixes.
(upd_pref_records): Skips empty items, evaluate all items.
* parse-packet.c (dump_sig_subpkt): Better listing of prefs.
(skip_packet): Now knows about marker packet
* g10.c: removed cmd "--edit-sig".
* pubring.asc: Updated.
Sat Nov 14 14:01:29 1998 Werner Koch (wk@isil.d.shuttle.de)
* g10.c (main): Changed syntax of --list-trust-path
* trustdb.c (list_trust_path): Replaced max_depth by
opt.max_cert_depth
Fri Nov 13 07:39:58 1998 Werner Koch <werner.koch@guug.de>
* trustdb.c (collect_paths): Removed a warning message.
(enum_trust_web): Removed.
(enum_cert_paths): New.
* pkclist.c (add_ownertrust): Changed to use enum_cert_paths.
(edit_ownertrust): Now list ceritficates on request.
(show_paths): New.
Wed Nov 11 18:05:44 1998 Werner Koch <werner.koch@guug.de>
* g10.c (main): New option --max-cert-depth
* tdbio.h: add new fields to ver and dir record.
* tdbio.c: read/write/dump of these fields.
(tdbio_db_matches_options): New.
* trustdb.c: replaced MAC_CERT_DEPTH by opt.max_cert_depth.
(do_check): cache validity and changed other functions
to reset the cached value.
* keylist.c (list_one): Now lists the ownertrust.
* mainproc.c (list_node): Ditto.
Tue Nov 10 10:08:59 1998 Werner Koch (wk@isil.d.shuttle.de)
* g10.c (g10_exit): Now looks at the new g10_errors_seen.
* mainproc.c (check_sig_and_print): Sets g10_errors_seen.
* *.c : i18n many more strings.
* ringedit.c (locate_keyblock_by_keyid): Add HAVE_LIBGDBM
(locate_keyblock_by_fpr): Ditto.
* g10.c (main): removed unsused "int errors".
(main): Add new option --charset.
* g10.c (main): special message for the unix newbie.
Mon Nov 9 07:17:42 1998 Werner Koch <werner.koch@guug.de>
* getkey.c (finish_lookup): Kludge to prefere algo 16.
* trustdb.c (new_lid_table): Clear cached item.
* status.c (cpr_get_utf8): New.
* pkclist.c (build_pk_list): Uses this.
Sun Nov 8 17:20:39 1998 Werner Koch (wk@isil.d.shuttle.de)
* mainproc.c (check_sig_and_print): Why did I use strlen()-1
in the printf? - This truncated the TZ.
Sat Nov 7 15:57:28 1998 me,,, (wk@tobold)
* getkey.c (lookup): Changes to support a read_next.
(get_pubkey): Fixed a memory leak.
* keylist.c (list_one): Now lists all matching user IDs.
Tue Nov 3 16:19:21 1998 Werner Koch (wk@isil.d.shuttle.de)
* keygen.c (ask_user_id): Now converted to UTF-8
* g10.c (main): Kludge for pgp clearsigs and textmode.
Fri Oct 30 16:40:39 1998 me,,, (wk@tobold)
* signal.c (block_all_signals): New.
(unblock_all_signals): New
* tdbio.c (tdbio_end_transaction): Now blocks all signals.
* trustdb.c (new_lid_table): Changed the representation of the
former local_lid_info stuff.
* trustdb.c (update_trust_record): Reorganized the whole thing.
* sig-check.c (check_key_signature): Now handles class 0x28
Wed Oct 28 18:56:33 1998 me,,, (wk@tobold)
* export.c (do_export): Takes care of the exportable sig flag.
Tue Oct 27 14:53:04 1998 Werner Koch (wk@isil.d.shuttle.de)
* trustdb.c (update_trust_record): New "fast" parameter.
Sun Oct 25 19:32:05 1998 Werner Koch (wk@isil.d.shuttle.de)
* openfile.c (copy_options_File): New.
* ringedit.c (add_keyblock_resource): Creates options file
* tdbio.c (tdbio_set_dbname): Ditto.
Sat Oct 24 14:10:53 1998 brian moore <bem@cmc.net>
* mainproc.c (proc_pubkey_enc): Don't release the DEK
(do_proc_packets): Ditto.
Fri Oct 23 06:49:38 1998 me,,, (wk@tobold)
* keyedit.c (keyedit_menu): Comments are now allowed
* trustdb.c: Rewrote large parts.
Thu Oct 22 15:56:45 1998 Michael Roth (mroth@nessie.de)
* encode.c: (encode_simple): Only the plain filename without
a given directory is stored in generated packets.
(encode_crypt): Ditto.
* sign.c: (sign_file) Ditto.
Thu Oct 22 10:53:41 1998 Werner Koch (wk@isil.d.shuttle.de)
* trustdb.c (update_trust_record): Add new optional arg.
* import.c (import_keys): Add statistics output
* trustdb.c (update_trustdb): Ditto.
(insert_trustdb): Ditto.
* tdbio.c (tdbio_begin_transaction): New.
(tdbio_end_transaction): New.
(tdbio_cancel_transaction): New.
* g10.c (main): New option --quit.
* trustdb.c (check_hint_sig): No tests for user-id w/o sig.
This caused an assert while checking the sigs.
* trustdb.c (upd_sig_record): Splitted into several functions.
* import.c (import_keys): New arg "fast".
* g10.c (main): New command --fast-import.
Wed Oct 21 18:19:36 1998 Michael Roth <mroth@nessie.de>
* ringedit.c (add_keyblock_resource): Directory is now created.
* tdbio.c (tdbio_set_dbname): New info message.
Wed Oct 21 11:52:04 1998 Werner Koch (wk@isil.d.shuttle.de)
* trustdb.c (update_trustdb): released keyblock in loop.
* keylist.c (list_block): New.
(list_all): Changed to use list_block.
* trustdb.c: Completed support for GDBM
* sign.c (only_old_style): Changed the way force_v3 is handled
(sign_file): Ditto.
(clearsign_file): Ditto.
* keygen.c (has_invalid_email_chars): Splitted into mailbox and
host part.
* keylist.c (list_one): Add a merge_keys_and_selfsig.
* mainproc.c (proc_tree): Ditto.
Sun Oct 18 11:49:03 1998 Werner Koch (wk@isil.d.shuttle.de)
* sign.c (only_old_style): Add option force_v3_sigs
(sign_file): Fixed a bug in sig->version
(clearsign_file): Ditto.
* parse-packet.c (dump_sig_subpkt): New
* keyedit.c (menu_expire): New.
* free-packet.c (cmp_signatures): New
Sat Oct 17 10:22:39 1998 Werner Koch (wk@isil.d.shuttle.de)
* armor.c: changed output line length from 72 to 64.
* keyedit.c (fix_keyblock): New.
Fri Oct 16 10:24:47 1998 Werner Koch (wk@isil.d.shuttle.de)
* trustdb.c: Rewrote most.
* tdbio.c: Add cache and generalized hash tables.
* options.h (ENABLE_COMMENT_PACKETS): New but undef'ed.
* encode.c, sign.c, keygen.c: Disabled comment packets.
* export.c (do_export): Comment packets are never exported,
except for those in the secret keyring.
* g10.c (main): Removed option do-no-export-rsa; should be
be replaced by a secpial tool.
* export.c (do_export): Removed the code for the above option.
* armor.c (find_header): Support for new only_keyblocks.
* import.c (import_keys): Only looks for keyblock armors.
* packet.h: replaced valid_days by expiredate and changed all users.
* build-packet.c (do_public_key): calculates valid-days
(do_secret_key): Ditto.
* parse-packet.c (parse_key): expiredate is calucated from the
valid_period in v3 packets.
* keyid.c (do_fingerprint_md): calculates valid_dates.
* keygen.c (add_key_expire): fixed key expiration time for v4 packets.
* armor.c (find_header): A LF in the first 28 bytes
was skipped for non-armored data.
Thu Oct 8 11:35:51 1998 Werner Koch (wk@isil.d.shuttle.de)
* armor.c (is_armored): Add test on old comment packets.
* tdbio.c (tdbio_search_dir_bypk): fixed memory leak.
* getkey.c: Changed the caching algorithms.
Wed Oct 7 19:33:28 1998 Werner Koch (wk@isil.d.shuttle.de)
* kbnodes.c (unused_nodes): New.
Wed Oct 7 11:15:36 1998 Werner Koch (wk@isil.d.shuttle.de)
* keyedit.c (sign_uids): Fixed a problem with SK which could caused
a save of an unprotected key.
(menu_adduid): Ditto.
* keyedit.c (keyedit_menu): Prefs are now correctly listed for
new user ids.
* trustdb.c (update_trust_record): New.
(insert_trust_record): Now makes use of update_trust_record.
Tue Oct 6 16:18:03 1998 Werner Koch (wk@isil.d.shuttle.de)
* trustdb.c (read_record): replaces most of the tdbio_read_records.
(write_record): Ditto.
Sat Oct 3 11:01:21 1998 Werner Koch (wk@isil.d.shuttle.de)
* keygen.c (ask_alogo): enable ElGamal enc-only only for addmode.
Wed Sep 30 10:15:33 1998 Werner Koch (wk@isil.d.shuttle.de)
* import.c (import_one): Fixed update of wrong keyblock.
Tue Sep 29 08:32:08 1998 me,,, (wk@tobold)
* mainproc.c (proc_plaintext): Display note for special filename.
* plaintext.c (handle_plaintext): Suppress output of special file.
Mon Sep 28 12:57:12 1998 Werner Koch (wk@isil.d.shuttle.de)
* g10.c (verify_own_keys): Add warning if a key is not protected.
* passphrase (hash_passphrase): Fixed iterated+salted mode and
setup for keysizes > hashsize.
* g10.c (main): New options: --s2k-{cipher,digest,mode}.
Fri Sep 25 09:34:23 1998 Werner Koch (wk@isil.d.shuttle.de)
* g10.c: Chnaged some help texts.
Tue Sep 22 19:34:39 1998 Werner Koch (wk@isil.d.shuttle.de)
* passphrase.c (read_passphrase_from_fd): fixed bug for long
passphrases.
Mon Sep 21 11:28:05 1998 Werner Koch (wk@(none))
* getkey.c (lookup): Add code to use the sub key if the primary one
does not match the usage.
* armor.c (armor_filter): New error message: no valid data found.
(radix64_read): Changes to support multiple messages.
(i18n.h): New.
* mainproc.c (add_onepass_sig): bug fix.
Mon Sep 21 08:03:16 1998 Werner Koch (wk@isil.d.shuttle.de)
* pkclist.c (do_we_trust): Add keyid to most messages.
* passphrase.c (read_passphrase_from_fd): New.
(have_static_passphrase): New
(get_passphrase_fd): Removed.
(set_passphrase_fd): Removed.
* g10.c (main): passphrase is now read here.
* keyedit.c (keyedit_menu): "help" texts should now translate fine.
Mon Sep 21 06:40:02 1998 Werner Koch (wk@isil.d.shuttle.de)
* encode.c (encode_simple): Now disables compression
when --rfc1991 is used.
(encode_crypt): Ditto.
Fri Sep 18 16:50:32 1998 Werner Koch (wk@isil.d.shuttle.de)
* getkey.c (merge_key_and_selfsig): New.
Fri Sep 18 10:20:11 1998 Werner Koch (wk@isil.d.shuttle.de)
* pkclist.c (select_algo_from_prefs): Removed 3DES kludge.
* seskey.c (make_session_key): Fixed SERIOUS bug introduced
by adding the weak key detection code.
* sign.c (sign_file): Changed aremor header in certain cases.
Tue Sep 15 17:52:55 1998 Werner Koch (wk@isil.d.shuttle.de)
* mainproc.c (check_sig_and_print): Replaced ascime by asctimestamp.
Mon Sep 14 11:40:52 1998 Werner Koch (wk@isil.d.shuttle.de)
* seskey.c (make_session_key): Now detects weak keys.
* trustdb (clear_trust_checked_flag): New.
* plaintext.c (handle_plaintext): Does no anymore suppress CR from
cleartext signed messages.
Sun Sep 13 12:54:29 1998 Werner Koch (wk@isil.d.shuttle.de)
* trustdb.c (insert_trust_record): Fixed a stupid bug in the free
liunked list loops.
Sat Sep 12 15:49:16 1998 Werner Koch (wk@isil.d.shuttle.de)
* status.c (remove_shmid): New.
(init_shm_comprocess): Now sets permission to the real uid.
Wed Sep 9 11:15:03 1998 Werner Koch (wk@isil.d.shuttle.de)
* packet.h (PKT_pubkey_enc): New flah throw_keyid, and add logic to
implement it.
* g10.c (main): New Option --throw-keyid
* getkey.c (enum_secret_keys): Add new ar and changed all callers.
Tue Sep 8 20:04:09 1998 Werner Koch (wk@isil.d.shuttle.de)
* delkey.c (delete_key): Moved from keyedit.c.
Mon Sep 7 16:37:52 1998 Werner Koch (wk@isil.d.shuttle.de)
* build-packet.c (calc_length_header): New arg new_ctb to correctly
calculate the length of new style packets.
* armor.c (is_armored): Checks for symkey_enc packets.
* pkclist.c (select_algo_from_prefs): 3DEs substitute is now CAST5.
Tue Aug 11 17:54:50 1998 Werner Koch (wk@isil.d.shuttle.de)
* build-packet.c (do_secret_key): Fixed handling of old keys.
* getkey.c (compare_name): Fixed exact and email matching
* openfile.c (open_outfile): Changed arguments and all callers.
Tue Aug 11 09:14:35 1998 Werner Koch (wk@isil.d.shuttle.de)
* encode.c (encode_simple): Applied option set-filename and comment.
(encode_crypt): Ditto.
* sign.c (sign_file): Ditto.
* armor.c (armor_filter): Applied option comment.
* encode.c (encode_crypt): Moved init_packet to the begin.
(encode_simple): add an init_packet().
* comment (write_comment): Now enforces a hash sign as the 1st byte.
* import.c (import_one): Add explanation for "no user ids".
* compress.c (do_uncompress): Applied Brian Warner's patch to support
zlib 1.1.3 etc.
* trustdb.c (check_trust): Fixed a problem after inserting new keys.
* getkey (lookup): do not return the primary key if usage is given
(lookup_sk): Ditto and take usage into account.
* status.c (cpr_get_answer_is_yes): add display_help.
Mon Aug 10 10:11:28 1998 Werner Koch (wk@isil.d.shuttle.de)
* getkey.c (lookup_sk): Now always returns the primary if arg
primary is true.
(lookup): Likewise.
(get_pubkey_byname): Now returns the primary key
(get_seckey_byname): Ditto.
Mon Aug 10 08:34:03 1998 Werner Koch (wk@isil.d.shuttle.de)
* keyid.c (pubkey_letter): ELG_E is now a small g.
Sat Aug 8 17:26:12 1998 Werner Koch (wk@isil.d.shuttle.de)
* openfile (overwrite_filep): Changed semantics and all callers.
Sat Aug 8 12:17:07 1998 Werner Koch (wk@isil.d.shuttle.de)
* status.c (display_help): New.
Thu Aug 6 16:30:41 1998 Werner Koch,mobil,,, (wk@tobold)
* seskey.c (encode_session_key): Now uses get_random_bits().
Thu Aug 6 07:34:56 1998 Werner Koch,mobil,,, (wk@tobold)
* ringedit.c (keyring_copy): No more backupfiles for
secret keyrings and add additional warning in case of
a failed secret keyring operation.
Wed Aug 5 11:54:37 1998 Werner Koch (wk@isil.d.shuttle.de)
* g10.c (check_opts): Moved to main. Changed def_cipher_algo
semantics and chnaged all users.
* pubkey-enc.c (get_sssion_key): New informational output
about preferences.
* parse-packet.c (parse_symkeyenc): Fixed salted+iterated S2K
(parse_key): Ditto.
* build-packet.c (do_secret_key): Ditto.
(do_symkey_enc): Ditto.
Tue Aug 4 08:59:10 1998 Werner Koch (wk@isil.d.shuttle.de)
* getkey.c (enum_secret_keys): Now returns only primary keys.
* getkey (lookup): Now sets the new namehash field.
* parse-packet.c (parse_sig_subpkt2): New.
* sign.c (sign_file): one-pass sigs are now emiited reverse.
Preference data is considered when selecting the compress algo.
Wed Jul 29 12:53:03 1998 Werner Koch (wk@isil.d.shuttle.de)
* free-packet.c (copy_signature): New.
* keygen.c (generate_subkeypair): rewritten
* g10.c (aKeyadd): Removed option --add-key
Mon Jul 27 10:37:28 1998 Werner Koch (wk@isil.d.shuttle.de)
* seckey-cert.c (do_check): Additional check on cipher blocksize.
(protect_secret_key): Ditto.
* encr-data.c: Support for other blocksizes.
* cipher.c (write_header): Ditto.
Fri Jul 24 16:47:59 1998 Werner Koch (wk@isil.d.shuttle.de)
* kbnode.c (insert_kbnode): Changed semantics and all callers.
* keyedit.c : More or less a complete rewrite
Wed Jul 22 17:10:04 1998 Werner Koch (wk@isil.d.shuttle.de)
* build-packet.c (write_sign_packet_header): New.
Tue Jul 21 14:37:09 1998 Werner Koch (wk@isil.d.shuttle.de)
* import.c (import_one): Now creates a trustdb record.
* g10.c (main): New command --check-trustdb
Mon Jul 20 11:15:07 1998 Werner Koch (wk@isil.d.shuttle.de)
* genkey.c (generate_keypair): Default key is now DSA with
encryption only ElGamal subkey.
Thu Jul 16 10:58:33 1998 Werner Koch (wk@isil.d.shuttle.de)
* keyid.c (keyid_from_fingerprint): New.
* getkey.c (get_pubkey_byfprint): New.
Tue Jul 14 18:09:51 1998 Werner Koch (wk@isil.d.shuttle.de)
* keyid.c (fingerprint_from_pk): Add argument and changed all callers.
(fingerprint_from_sk): Ditto.
Tue Jul 14 10:10:03 1998 Werner Koch (wk@isil.d.shuttle.de)
* plaintext.c (handle_plaintext): Now returns create error if
the file could not be created or the user responded not to overwrite
the file.
* mainproc.c (proc_plaintext): Tries again if the file could not
be created to check the signature without output.
* misc.c (disable_core_dumps): New.
* g10.c (main): disable coredumps for gpg
* g10.c (MAINTAINER_OPTIONS): New to disable some options
Mon Jul 13 16:47:54 1998 Werner Koch (wk@isil.d.shuttle.de)
* plaintext.c (hash_datafiles): New arg for better support of
detached sigs. Changed all callers.
* mainproc.c (proc_signature_packets): Ditto.
* g10.c (main): New option "compress-sigs"
* sig.c (sign_file): detached signatures are not anymore compressed
unless the option --compress-sigs is used.
Thu Jul 9 19:54:54 1998 Werner Koch (wk@isil.d.shuttle.de)
* armor.c: Fixes to allow zero length cleartext signatures
Thu Jul 9 14:52:47 1998 Werner Koch (wk@isil.d.shuttle.de)
* g10.c (build_list): Now drops setuid.
(main): Changed the way keyrings and algorithms are registered .
Wed Jul 8 14:17:30 1998 Werner Koch (wk@isil.d.shuttle.de)
* packet.h (PKT_public_key): Add field keyid.
* parse-packet.c (parse_key): Reset the above field.
* keyid.c (keyid_from_pk): Use above field as cache.
* tdbio.c, tdbio.h: New
* trustdb.c: Moved some functions to tdbio.c.
(print_keyid): New.
* pkclist.c (check_signatures_trust): New.
Wed Jul 8 10:45:28 1998 Werner Koch (wk@isil.d.shuttle.de)
* plaintext.c (special_md_putc): New.
(handle_plaintext): add clearsig argument
* mainproc.c (proc_plaintext): detection of clearsig
* sign.c (write_dased_escaped): Changed clearsig format
Tue Jul 7 18:56:19 1998 Werner Koch (wk@isil.d.shuttle.de)
* armor.c (find_header): Now makes sure that there is only one
empty line for clearsigs, as this is what OP now says.
Mon Jul 6 13:09:07 1998 Werner Koch (wk@isil.d.shuttle.de)
* g10.c (main): New option default-secret-key
* getkey.c (get_seckey_byname): support for this option.
Mon Jul 6 09:03:49 1998 Werner Koch (wk@isil.d.shuttle.de)
* getkey.c (add_keyring): Keyrings are now added to end of the
list of keyrings. The first added keyringwill be created.
(add_secret_keyring): Likewise.
* ringedit.c (add_keyblock_resource): Files are created here.
* g10.c (aNOP): Removed
* getkey.c (lookup): Add checking of usage for name lookups
* packet.h (pubkey_usage): Add a field which may be used to store
usage capabilities.
* pkclist.c (build_pk_list): getkey now called with usage arg.
* skclist.c (build_sk_list): Ditto.
* sign.c (clearsign_file): Fixed "Hash:" headers
Sat Jul 4 13:33:31 1998 Werner Koch (wk@isil.d.shuttle.de)
* trustdb.c (list_ownertrust): New.
* g10.c (aListOwnerTrust): New.
* g10.c (def_pubkey_algo): Removed.
* trustdb.c (verify_private_data): Removed and also the call to it.
(sign_private_data): Removed.
Fri Jul 3 13:26:10 1998 Werner Koch (wk@isil.d.shuttle.de)
* g10.c (aEditKey): was aEditSig. Changed usage msg.
* keyedit.c: Done some i18n stuff.
* g10.c (do_not_use_RSA): New.
* sign.c (do_sign): Add call to above function.
* encode.c (write_pubkey_enc_from_list): Ditto.
Thu Jul 2 21:01:25 1998 Werner Koch (wk@isil.d.shuttle.de)
* parse-packet.c: Now is able sto store data of unknown
algorithms.
* free-packet.c: Support for this.
* build-packet.c: Can write data of packet with unknown algos.
Thu Jul 2 11:46:36 1998 Werner Koch (wk@isil.d.shuttle.de)
* parse-packet.c (parse): fixed 4 byte length header
Wed Jul 1 12:36:55 1998 Werner Koch (wk@isil.d.shuttle.de)
* packet.h (new_ctb): New field for some packets
* build-packet.c (build_packet): Support for new_ctb
* parse-packet.c (parse): Ditto.
Mon Jun 29 12:54:45 1998 Werner Koch (wk@isil.d.shuttle.de)
* packet.h: changed all "_cert" to "_key", "subcert" to "subkey".
* free-packet.c (free_packet): Removed memory leak for subkeys.
Sun Jun 28 18:32:27 1998 Werner Koch (wk@isil.d.shuttle.de)
* import.c (import_keys): Renamed from import_pubkeys.
(import_secret_one): New.
* g10.c (aExportSecret): New.
* export.c (export_seckeys): New.
* parse-packet.c (parse_certificate): Cleaned up.
(parse_packet): Trust packets are now considered as unknown.
(parse_pubkey_warning): New.
Fri Jun 26 10:37:35 1998 Werner Koch (wk@isil.d.shuttle.de)
* keygen.c (has_invalid_email_chars): New.
Wed Jun 24 16:40:22 1998 Werner Koch (wk@isil.d.shuttle.de)
* armor.c (armor_filter): Now creates valid onepass_sig packets
with all detected hash algorithms.
* mainproc.c (proc_plaintext): Now uses the hash algos as specified
in the onepass_sig packets (if there are any)
Mon Jun 22 11:54:08 1998 Werner Koch (wk@isil.d.shuttle.de)
* plaintext.c (handle_plaintext): add arg to disable outout
* mainproc.c (proc_plaintext): disable output when in sigs_only mode.
Thu Jun 18 13:17:27 1998 Werner Koch (wk@isil.d.shuttle.de)
* keygen.c: Removed all rsa packet stuff, chnaged defaults
for key generation.
Sun Jun 14 21:28:31 1998 Werner Koch (wk@isil.d.shuttle.de)
* misc.c (checksum_u16): Fixed a stupid bug which caused a
wrong checksum calculation for the secret key protection and
add a backward compatibility option.
* g10.c (main): Add option --emulate-checksum-bug.
Thu Jun 11 13:26:44 1998 Werner Koch (wk@isil.d.shuttle.de)
* packet.h: Major changes to the structure of public key material
which is now stored in an array and not anaymore in a union of
algorithm specific structures. These is needed to make the system
more extendable and makes a lot of stuff much simpler. Changed
all over the system.
* dsa.c, rsa.c, elg.c: Removed.
Wed Jun 10 07:22:02 1998 Werner Koch,mobil,,, (wk@tobold)
* g10.c ("load-extension"): New option.
Mon Jun 8 22:23:37 1998 Werner Koch (wk@isil.d.shuttle.de)
* seckey-cert.c (do_check): Removed cipher constants
(protect_secret_key): Ditto.
Fri May 29 10:00:28 1998 Werner Koch (wk@isil.d.shuttle.de)
* trustdb.c (query_trust_info): New.
* keylist.c (list_one): Add output of trust info
* mainproc (list_node): ditto.
* g10.c (main): full trustdb init if -with-colons and any of the
key list modes.
Thu May 28 10:34:42 1998 Werner Koch (wk@isil.d.shuttle.de)
* status.c (STATUS_RSA_OR_IDEA): New.
* sig-check.c (check_signature): Output special status message.
* pubkey-enc.c (get_session_key): Ditto.
* mainproc.c (check_sig_and_print): Changed format of output.
* passpharse.c (passphrase_to_dek): Likewise.
Wed May 27 13:46:48 1998 Werner Koch (wk@isil.d.shuttle.de)
* g10.c (aListSecretKeys): New option --list-secret-keys
* keylist.c (std_key_list): Renamed to public_key_list.
(secret_key_list): New
(list_one, list_all): Add support for secret keys.
* getkey.c (get_secret_keyring): New.
* mainproc.c (list_node): Add option --with-colons for secret keys
* sig-check.c (check_key_signature): detection of selfsigs
* mainproc.c (list_node): fixed listing.
* g10.c (aListSecretKeys): New option --always-trust
* pkclist.c (do_we_trust): Override per option added
* status.c (write_status_text): Add a prefix to every output line.
Wed May 27 07:49:21 1998 Werner Koch (wk@isil.d.shuttle.de)
* g10 (--compress-keys): New.
* options.h (compress_keys): New.
* export.c (export_pubkeys): Only compresses with the new option.
Tue May 26 11:24:33 1998 Werner Koch (wk@isil.d.shuttle.de)
* passphrase.c (get_last_passphrase): New
(set_next_passphrase): New.
(passphrase_to_dek): add support for the above functions.
* keyedit.c (make_keysig_packet): Add sigclass 0x18,
changed all callers due to a new argument.
* keygen.c (write_keybinding): New
(generate_subkeypair): Add functionality
(ask_algo, ask_keysize, ask_valid_days): Broke out of generate_keypair
(ask_user_id, ask_passphrase): Ditto.
Thu May 21 11:26:13 1998 Werner Koch (wk@isil.d.shuttle.de)
* g10.c,gpgd.c (main): Does now return an int, so that egcs does
not complain.
* armor.c (fake_packet): Removed erro message and add a noticed
that this part should be fixed.
* sign.c (sign_file): Compression now comes in front of encryption.
* encode.c (encode_simple): Ditto.
(encode_crypt): Ditto.
Tue May 19 16:18:19 1998 Werner Koch (wk@isil.d.shuttle.de)
* armor.c (fake_packet): Changed assertion to log_error
Sat May 16 16:02:06 1998 Werner Koch (wk@isil.d.shuttle.de)
* build-packet.c (build_packet): Add SUBKEY packets.
Fri May 15 17:57:23 1998 Werner Koch (wk@isil.d.shuttle.de)
* sign.c (hash_for): New and used in all places here.
* main.h (DEFAULT_): new macros.
* g10.c (opt.def_digest_algo): Now set to 0
* compress.c (init_compress): Add support for algo 1
* options.h (def_compress_algo): New
* g10.c (main): New option --compress-algo
Fri May 15 13:23:59 1998 Werner Koch (wk@isil.d.shuttle.de)
* g10.c (print_mds): New feature to print only one hash,
chnaged formatting.
Thu May 14 15:36:24 1998 Werner Koch (wk@isil.d.shuttle.de)
* misc.c (trap_unaligned) [__alpha__]: New
* g10.c (trap_unaligned): Add call to this to track down SIGBUS
on Alphas (to avoid the slow emulation code).
Wed May 13 11:48:27 1998 Werner Koch (wk@isil.d.shuttle.de)
* build-packet.c (do_signature): Support for v4 pakets.
* keyedit.c (make_keysig_packet): Ditto.
* build-packet.c (build_sig_subpkt_from_sig): New.
(build_sig_subpkt): New.
* elg.c (g10_elg_sign): removed keyid_from_skc.
* dsa.c (g10_dsa_sign): Ditto.
* rsa.c (g10_rsa_sign): Ditto.
* keyedit.c (make_keysig_packet): Add call to keyid_from_skc
* sign.c (clearsign_file): Support for v4 signatures.
(sign_file): Ditto.
Wed May 6 09:31:24 1998 Werner Koch (wk@isil.d.shuttle.de)
* parse-packet.c (do_parse): add support for 5 byte length leader.
(parse_subpkt): Ditto.
* build-packet.c (write_new_header): Ditto.
* packet.h (SIGSUBPKT_): New constants.
* parse-packet.c (parse_sig_subpkt): Changed name, made global,
and arg to return packet length, chnaged all callers
Tue May 5 22:11:59 1998 Werner Koch (wk@isil.d.shuttle.de)
* keygen.c (gen_dsa): New.
* build_packet.c (do_secret_cert): Support for DSA
Mon May 4 19:01:25 1998 Werner Koch (wk@isil.d.shuttle.de)
* compress.c: doubled buffer sizes
* parse-packet.c (do_plaintext): now uses iobuf_read/write.
Mon May 4 09:35:53 1998 Werner Koch (wk@isil.d.shuttle.de)
* seskey.c (encode_md_value): Add optional argument hash_algo,
changed all callers.
* passphrase.c (make_dek_from_passphrase): Removed
* (get_passhrase_hash): Changed name to passphrase_to_dek, add arg,
changed all callers.
* all: Introduced the new ELG identifier and added support for the
encryption only one (which is okay to use by GNUPG for signatures).
Sun May 3 17:50:26 1998 Werner Koch (wk@isil.d.shuttle.de)
* packet.h (PKT_OLD_COMMENT): New name for type 16.
* parse-packet.c (parse_comment): Now uses type 61
Fri May 1 12:44:39 1998 Werner Koch,mobil,,, (wk@tobold)
* packet.h (count): Chnaged s2k count from byte to u32.
* seckey-cert.c (do_check): Changed s2k algo 3 to 4, changed
reading of count.
* build-packet.c (do_secret_cert): ditto.
* parse-packet.c (parse_certificate): ditto.
* parse-packet.c (parse_symkeyenc): New.
* build-packet.c (do_symkey_enc): New.
Thu Apr 30 16:33:34 1998 Werner Koch (wk@isil.d.shuttle.de)
* sign.c (clearsign_file): Fixed "Hash: " armor line.
Tue Apr 28 14:27:42 1998 Werner Koch (wk@isil.d.shuttle.de)
* parse-packet.c (parse_subpkt): Some new types.
Mon Apr 27 12:53:59 1998 Werner Koch (wk@isil.d.shuttle.de)
* g10.c (main): Add option --skip-verify.
* mainproc.c (check_sig_and_print): Ditto.
* g10.c (print_mds): Add output for Tiger.
* sign.c (sign_file): Now uses partial length headers if used
in canonical textmode (kludge to fix a bug).
* parse-packet.c (parse_certificate): Changed BLOWFISH id.
* pubkey-enc.c (get_session_key): Ditto.
* seskey.c (make_session_key): Ditto.
* seckey-cert.c (protect_secret_key,do_check): Add BLOWFISH160.
Fri Apr 24 17:38:48 1998 Werner Koch,mobil,,, (wk@tobold)
* sig-check.c (check_key_signature): Add sig-class 0x14..0x17
* keyedit.c (sign-key): Some changes to start with support of
the above new sig-classes.
Wed Apr 22 09:01:57 1998 Werner Koch,mobil,,, (wk@tobold)
* getkey.c (compare_name): add email matching
Tue Apr 21 16:17:12 1998 Werner Koch,mobil,,, (wk@tobold)
* armor.c (armor_filter): fixed missing last LF before CSUM.
Thu Apr 9 11:35:22 1998 Werner Koch (wk@isil.d.shuttle.de)
* seckey-cert.c (do_check): New; combines all the check functions
into one.
* sign.c: removed all key management functions
* keyedit.c: New.
Thu Apr 9 09:49:36 1998 Werner Koch (wk@isil.d.shuttle.de)
* import.c (chk_self_sigs): Changed an error message.
Wed Apr 8 16:19:39 1998 Werner Koch (wk@isil.d.shuttle.de)
* packet.h: packet structs now uses structs from the pubkey,
removed all copy operations from packet to pubkey structs.
Wed Apr 8 13:40:33 1998 Werner Koch (wk@isil.d.shuttle.de)
* trustdb.c (verify_own_certs): Fixed "public key not found".
* getkey.c (key_byname): New, combines public and secret key search.
* pkclist.c (build_pkc_list): Add new arg usage, changed all callers.
* skclist.c (build_skc_list): Likewise.
* ringedit.c (find_keyblock, keyring_search2): Removed.
Wed Apr 8 09:47:21 1998 Werner Koch (wk@isil.d.shuttle.de)
* sig-check.c (do_check): Applied small fix from Ulf Möller.
Tue Apr 7 19:28:07 1998 Werner Koch (wk@isil.d.shuttle.de)
* cipher.c, encr-data.c, seckey-cert.c: Now uses cipher_xxxx
functions instead of blowfish_xxx or cast_xxx
Tue Apr 7 11:04:02 1998 Werner Koch (wk@isil.d.shuttle.de)
* Makefile.am (g10maint.o): Changed the way it is created.
Mon Apr 6 11:17:08 1998 Werner Koch (wk@isil.d.shuttle.de)
* misc.c: New.
* keygen.c (checksum,checksum_u16,checksum_mpi): Moved to misc.c
* seckey-cert.c: Kludge for wrong ELG checksum implementation.
Sat Apr 4 20:07:01 1998 Werner Koch (wk@isil.d.shuttle.de)
* cipher.c (cipher_filter): Support for CAST5
* encr-data.c (decode_filter): Ditto.
(decrypt_data): Ditto.
* seskey.c (make_session_key): Ditto.
* seckey-cert.c (check_elg, check_dsa): Ditto,
(protect_secret_key): Ditto.
* pubkey-enc.c (get_session_key): Ditto.
* passphrase.c (hash_passphrase): Ditto.
Thu Apr 2 20:22:35 1998 Werner Koch (wk@isil.d.shuttle.de)
* gpgd.c: New
Thu Apr 2 10:38:16 1998 Werner Koch (wk@isil.d.shuttle.de)
* keygen.c (generate_keypair): Add valid_days stuff.
* trustdb.c (check_trust): Add check for valid_days.
Wed Apr 1 16:15:58 1998 Werner Koch (wk@isil.d.shuttle.de)
* keygen.c (generate_keypair): Addional question whether the
selected large keysize is really needed.
Wed Apr 1 15:56:33 1998 Werner Koch (wk@isil.d.shuttle.de)
* seckey-cert.c (protect_secret_key): merged protect_xxx to here.
Wed Apr 1 10:34:46 1998 Werner Koch (wk@isil.d.shuttle.de)
* Makefile.am (g10maint.c): Changed creation rule, so that it works
on FreeBSD (missing CFLAGS).
* parse-packet.c (parse_subkey): Removed.
Thu Mar 19 15:22:36 1998 Werner Koch (wk@isil.d.shuttle.de)
* ringedit.c (keyring_enum): Fixed problem with reading too
many packets. Add support to read secret keyrings.
* getkey.c (scan_keyring): Removed
(lookup): New to replace scan_keyring.
(scan_secret_keyring): Removed.
(lookup_skc): New.
Wed Mar 18 11:47:34 1998 Werner Koch (wk@isil.d.shuttle.de)
* ringedit.c (enum_keyblocks): New read mode 11.
* keyid.c (elg_fingerprint_md): New and changed all other functions
to call this if the packet version is 4 or above.
Tue Mar 17 20:46:16 1998 Werner Koch (wk@isil.d.shuttle.de)
* parse-packet.c (parse_certificate): Add listing support for subkeys.
Tue Mar 17 20:32:22 1998 Werner Koch (wk@isil.d.shuttle.de)
* armor.c (is_armored): Allow marker packet.
Thu Mar 12 13:36:49 1998 Werner Koch (wk@isil.d.shuttle.de)
* trustdb.c (check_trust): Checks timestamp of pubkey.
* sig-check. (do_check): Compares timestamps.
Tue Mar 10 17:01:56 1998 Werner Koch (wk@isil.d.shuttle.de)
* g10.c (main): Add call to init_signals.
* signal.c: New.
Mon Mar 9 12:43:42 1998 Werner Koch (wk@isil.d.shuttle.de)
* dsa.c: New
* packet.h, free-packet.c, parse-packet.c : Add support for DSA
* sig-check.c, getkey.c, keyid.c, ringedit.c: Ditto.
* seckey-cert.c: Ditto.
* packet.h : Moved .digest_algo of signature packets to outer
structure. Changed all references
Sun Mar 8 13:06:42 1998 Werner Koch (wk@isil.d.shuttle.de)
* openfile.c : Support for stdout filename "-".
* mainproc.c (check_sig_and_print): Enhanced status output:
* status.c (write_status_text): New.
Fri Mar 6 16:10:54 1998 Werner Koch (wk@isil.d.shuttle.de)
* kbnode.c (clone_kbnode): Fixed private_flag.
* mainproc.c (list_node): Output of string "Revoked" as user-id.
Fri Mar 6 14:26:39 1998 Werner Koch (wk@isil.d.shuttle.de)
* g10.c (main): Add userids to "-kv" and cleaned up this stuff.
Fri Mar 6 12:45:58 1998 Werner Koch (wk@isil.d.shuttle.de)
* g10.c (main): Changed semantics of the list-... commands
and added a new one. Removed option "-d"
* decrypt.c: New.
* trustdb.c (init_trustdb): Autocreate directory only if it ends
in "/.gnupg".
Thu Mar 5 12:12:11 1998 Werner Koch (wk@isil.d.shuttle.de)
* mainproc.c (do_proc_packets): New. Common part of proc_packet.
(proc_signature_packets): special version to handle signature data.
* verify.c: New.
* g10.c (aVerify): New.
* plaintext.c (hash_datafiles): New.
* compress.c (handle_compressed): Add callback arg, changed caller.
Thu Mar 5 10:20:06 1998 Werner Koch (wk@isil.d.shuttle.de)
* g10.c: Is nom the common source for gpg and gpgm
* g10maint.c: Removed
* Makefile.am: Add rule to build g10maint.c
Thu Mar 5 08:43:59 1998 Werner Koch (wk@isil.d.shuttle.de)
* g10.c (main): Changed the way clear text sigs are faked.
Wed Mar 4 19:47:37 1998 Werner Koch (wk@isil.d.shuttle.de)
* g10maint.c (aMuttKeyList): New
* keylist.c: New.
Wed Mar 4 17:20:33 1998 Werner Koch (wk@isil.d.shuttle.de)
* getkey.c (get_pubkey_byname): Kludge to allow 0x prefix.
Tue Mar 3 13:46:55 1998 Werner Koch (wk@isil.d.shuttle.de)
* g10maint.c (main): New option --gen-random.
Tue Mar 3 09:50:08 1998 Werner Koch (wk@isil.d.shuttle.de)
* g10.c (aDeleteSecretKey): New.
(aEditSig): Add option "--edit-key" as synonym for "--edit-sig".
(aDeleteSecretKey): New.
* getkey.c (seckey_available): New.
* sign.c (delete_key): Enhanced to delete secret keys, changed all
callers.
Mon Mar 2 21:23:48 1998 Werner Koch (wk@isil.d.shuttle.de)
* pkc_list.c (build_pkc_list): Add interactive input of user ID.
Mon Mar 2 20:54:05 1998 Werner Koch (wk@isil.d.shuttle.de)
* pkclist.c (do_we_trust_pre): New.
(add_ownertrust): Add message.
* trustdb.c (enum_trust_web): Quick fix.
Mon Mar 2 13:50:53 1998 Werner Koch (wk@isil.d.shuttle.de)
* g10.c (main): New action aDeleteKey
* sign.c (delete_key): New.
Sun Mar 1 16:38:58 1998 Werner Koch (wk@isil.d.shuttle.de)
* trustdb.c (do_check): No returns TRUST_UNDEFINED instead of
eof error.
Fri Feb 27 18:14:03 1998 Werner Koch (wk@isil.d.shuttle.de)
* armor.c (find_header): Removed trailing CR on headers.
Fri Feb 27 18:02:48 1998 Werner Koch (wk@isil.d.shuttle.de)
* ringedit.c (keyring_search) [MINGW32]: Open and close file here
because rename does not work on open files. Chnaged callers.
Fri Feb 27 16:43:11 1998 Werner Koch (wk@isil.d.shuttle.de)
* sig-check.c (do_check): Add an md_enable.
* mainproc.c (do_check_sig): Use md_open in case of detached sig
(proc_tree): Take detached sigs into account.
Fri Feb 27 15:22:46 1998 Werner Koch (wk@isil.d.shuttle.de)
* g10.c (main): Make use of GNUPGHOME envvar.
* g10main.c (main): Ditto.
Wed Feb 25 11:40:04 1998 Werner Koch (wk@isil.d.shuttle.de)
* plaintext.c (ask_for_detached_datafile): add opt.verbose to
info output.
* openfile.c (open_sigfile): Try also name ending in ".asc"
Wed Feb 25 08:41:00 1998 Werner Koch (wk@isil.d.shuttle.de)
* keygen.c (generate_keypair): Fixed memory overflow.
Tue Feb 24 15:51:55 1998 Werner Koch (wk@isil.d.shuttle.de)
* parse-packet.c (parse_certificate): Support for S2K.
* build-packet.c (do_secret_cert): Ditto.
* keygen.c (gen_elg): Ditto.
* seckey-cert.c (check_elg): Ditto
(protect_elg): Ditto.
* sign.c (chnage_passphrase): Ditto.
* passphrase.c (get_passphrase_hash): Support for a salt and
changed all callers.
(make_dek_from_passphrase): Ditto.
Tue Feb 24 12:30:56 1998 Werner Koch (wk@isil.d.shuttle.de)
* build-packet.c (hash_public_cert): Disabled debug output.
Fri Feb 20 17:22:28 1998 Werner Koch (wk@isil.d.shuttle.de)
* trustdb.c (init_trustdb) [MINGW32]: Removed 2nd mkdir arg.
(keyring_copy) [MINGW32]: Add a remove prior to the renames.
Wed Feb 18 18:39:02 1998 Werner Koch (wk@isil.d.shuttle.de)
* Makefile.am (OMIT_DEPENDENCIES): New.
* rsa.c: Replaced log_bug by BUG.
Wed Feb 18 13:35:58 1998 Werner Koch (wk@isil.d.shuttle.de)
* mainproc.c (do_check_sig): Now uses hash_public_cert.
* parse-packet.c (parse_certificate): Removed hashing.
* packet.h (public_cert): Removed hash variable.
* free-packet.c (copy_public_cert, free_public_cert): Likewise.
* sig-check.c (check_key_signatures): Changed semantics.
Wed Feb 18 12:11:28 1998 Werner Koch (wk@isil.d.shuttle.de)
* trustdb.c (do_check): Add handling for revocation certificates.
(build_sigrecs): Ditto.
(check_sigs): Ditto.
Wed Feb 18 09:31:04 1998 Werner Koch (wk@isil.d.shuttle.de)
* armor.c (armor_filter): Add afx->hdrlines.
* revoke.c (gen_revoke): Add comment line.
* dearmor.c (enarmor_file): Ditto.
* sig-check.c (check_key_signature): Add handling for class 0x20.
* mainproc.c : Ditto.
Tue Feb 17 21:24:17 1998 Werner Koch (wk@isil.d.shuttle.de)
* armor.c : Add header lines "...ARMORED FILE .."
* dearmor.c (enarmor_file): New.
* g10maint.c (main): New option "--enarmor"
Tue Feb 17 19:03:33 1998 Werner Koch (wk@isil.d.shuttle.de)
* mainproc.c : Changed a lot, because the packets are now stored
a simple linlked list and not anymore in a complicatd tree structure.
Tue Feb 17 10:14:48 1998 Werner Koch (wk@isil.d.shuttle.de)
* free_packet.c (cmp_public_certs): New.
(cmp_user_ids): New.
* kbnode.c (clone_kbnode): New.
(release_kbnode): Add clone support.
* ringedit.c (find_keyblock_bypkc): New.
* sign.c (remove_keysigs): Self signatures are now skipped,
changed arguments and all callers.
* import.c : Add functionality.
Tue Feb 17 09:31:40 1998 Werner Koch (wk@isil.d.shuttle.de)
* options.h (homedir): New option.
* g10.c, g10maint.c, getkey.c, keygen.c, trustdb.c (opt.homedir): New.
* trustdb.c (init_trustdb): mkdir for hoem directory
(sign_private_data): Renamed "sig" to "g10.sig"
Mon Feb 16 20:02:03 1998 Werner Koch (wk@isil.d.shuttle.de)
* kbnode.c (commit_kbnode): New.
(delete_kbnode): removed unused first arg. Changed all Callers.
* ringedit.c (keyblock_resource_name): New.
(get_keyblock_handle): NULL for filename returns default resource.
Mon Feb 16 19:38:48 1998 Werner Koch (wk@isil.d.shuttle.de)
* sig-check.s (check_key_signature): Now uses the supplied
public key to check the signature and not any more the one
from the getkey.c
(do_check): New.
(check_signature): Most work moved to do_check.
Mon Feb 16 14:48:57 1998 Werner Koch (wk@isil.d.shuttle.de)
* armor.c (find_header): Fixed another bug.
Mon Feb 16 12:18:34 1998 Werner Koch (wk@isil.d.shuttle.de)
* getkey.c (scan_keyring): Add handling of compressed keyrings.
Mon Feb 16 10:44:51 1998 Werner Koch (wk@isil.d.shuttle.de)
* g10.c, g10maint.c (strusage): Rewrote.
(build_list): New
Mon Feb 16 08:58:41 1998 Werner Koch (wk@isil.d.shuttle.de)
* armor.c (use_armor): New.
Sat Feb 14 14:30:57 1998 Werner Koch (wk@isil.d.shuttle.de)
* mainproc.c (proc_tree): Sigclass fix.
Sat Feb 14 14:16:33 1998 Werner Koch (wk@isil.d.shuttle.de)
* armor.c (armor_filter): Changed version and comment string.
* encode.c, sign.c, keygen.c: Changed all comment packet strings.
Sat Feb 14 12:39:24 1998 Werner Koch (wk@isil.d.shuttle.de)
* g10.c (aGenRevoke): New command.
* revoke.c: New.
* sign.c (make_keysig_packet): Add support for sigclass 0x20.
Fri Feb 13 20:18:14 1998 Werner Koch (wk@isil.d.shuttle.de)
* ringedit.c (enum_keyblocks, keyring_enum): New.
Fri Feb 13 19:33:40 1998 Werner Koch (wk@isil.d.shuttle.de)
* export.c: Add functionality.
* keygen.c (generate_keypair): Moved the leading comment behind the
key packet.
* kbnode.c (walk_kbnode): Fixed.
* g10.c (main): listing armored keys now work.
Fri Feb 13 16:17:43 1998 Werner Koch (wk@isil.d.shuttle.de)
* parse-packet.c (parse_publickey, parse_signature): Fixed calls
to mpi_read used for ELG b.
Fri Feb 13 15:13:23 1998 Werner Koch (wk@isil.d.shuttle.de)
* g10.c (main): changed formatting of help output.
Thu Feb 12 22:24:42 1998 Werner Koch (wk@frodo)
* pubkey-enc.c (get_session_key): rewritten
diff --git a/g10/armor.c b/g10/armor.c
index 78656bae9..ca74fe448 100644
--- a/g10/armor.c
+++ b/g10/armor.c
@@ -1,1190 +1,1190 @@
/* armor.c - Armor flter
* Copyright (C) 1998 Free Software Foundation, Inc.
*
* This file is part of GnuPG.
*
* GnuPG 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.
*
* GnuPG 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 <errno.h>
#include <assert.h>
#include "errors.h"
#include "iobuf.h"
#include "memory.h"
#include "util.h"
#include "filter.h"
#include "packet.h"
#include "options.h"
#include "main.h"
#include "status.h"
#include "i18n.h"
#define CRCINIT 0xB704CE
#define CRCPOLY 0X864CFB
#define CRCUPDATE(a,c) do { \
a = ((a) << 8) ^ crc_table[((a)&0xff >> 16) ^ (c)]; \
a &= 0x00ffffff; \
} while(0)
static u32 crc_table[256];
static byte bintoasc[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
"abcdefghijklmnopqrstuvwxyz"
"0123456789+/";
static byte asctobin[256]; /* runtime initialized */
static int is_initialized;
typedef enum {
fhdrHASArmor = 0,
fhdrNOArmor,
fhdrINIT,
fhdrINITCont,
fhdrINITSkip,
fhdrCHECKBegin,
fhdrWAITHeader,
fhdrWAITClearsig,
fhdrSKIPHeader,
fhdrCLEARSIG,
fhdrREADClearsig,
fhdrNullClearsig,
fhdrEMPTYClearsig,
fhdrCHECKClearsig,
fhdrCHECKClearsig2,
fhdrCHECKDashEscaped,
fhdrCHECKDashEscaped2,
fhdrCHECKDashEscaped3,
fhdrREADClearsigNext,
fhdrENDClearsig,
fhdrENDClearsigHelp,
fhdrTESTSpaces,
fhdrCLEARSIGSimple,
fhdrCLEARSIGSimpleNext,
fhdrTEXT,
fhdrTEXTSimple,
fhdrERROR,
fhdrERRORShow,
fhdrEOF
} fhdr_state_t;
/* if we encounter this armor string with this index, go
* into a mode which fakes packets and wait for the next armor */
#define BEGIN_SIGNED_MSG_IDX 3
static char *head_strings[] = {
"BEGIN PGP MESSAGE",
"BEGIN PGP PUBLIC KEY BLOCK",
"BEGIN PGP SIGNATURE",
"BEGIN PGP SIGNED MESSAGE",
"BEGIN PGP ARMORED FILE", /* gnupg extension */
"BEGIN PGP PRIVATE KEY BLOCK",
"BEGIN PGP SECRET KEY BLOCK", /* only used by pgp2 */
NULL
};
static char *tail_strings[] = {
"END PGP MESSAGE",
"END PGP PUBLIC KEY BLOCK",
"END PGP SIGNATURE",
"END dummy",
"END PGP ARMORED FILE",
"END PGP PRIVATE KEY BLOCK",
"END PGP SECRET KEY BLOCK",
NULL
};
static fhdr_state_t find_header( fhdr_state_t state,
byte *buf, size_t *r_buflen,
IOBUF a, size_t n,
unsigned *r_empty, int *r_hashes,
int only_keyblocks, int *not_dashed );
static void
initialize(void)
{
int i, j;
u32 t;
byte *s;
/* init the crc lookup table */
crc_table[0] = 0;
for(i=j=0; j < 128; j++ ) {
t = crc_table[j];
if( t & 0x00800000 ) {
t <<= 1;
crc_table[i++] = t ^ CRCPOLY;
crc_table[i++] = t;
}
else {
t <<= 1;
crc_table[i++] = t;
crc_table[i++] = t ^ CRCPOLY;
}
}
/* build the helptable for radix64 to bin conversion */
for(i=0; i < 256; i++ )
asctobin[i] = 255; /* used to detect invalid characters */
for(s=bintoasc,i=0; *s; s++,i++ )
asctobin[*s] = i;
is_initialized=1;
}
/****************
* Check whether this is an armored file or not
* See also parse-packet.c for details on this code
* Returns: True if it seems to be armored
*/
static int
is_armored( byte *buf )
{
int ctb, pkttype;
ctb = *buf;
if( !(ctb & 0x80) )
return 1; /* invalid packet: assume it is armored */
pkttype = ctb & 0x40 ? (ctb & 0x3f) : ((ctb>>2)&0xf);
switch( pkttype ) {
case PKT_MARKER:
case PKT_SYMKEY_ENC:
case PKT_PUBLIC_KEY:
case PKT_SECRET_KEY:
case PKT_PUBKEY_ENC:
case PKT_SIGNATURE:
case PKT_COMMENT:
case PKT_OLD_COMMENT:
case PKT_PLAINTEXT:
case PKT_COMPRESSED:
case PKT_ENCRYPTED:
return 0; /* seems to be a regular packet: not armored */
}
return 1;
}
/****************
* Try to check whether the iobuf is armored
* Returns true if this may be the case; the caller should use the
* filter to do further processing.
*/
int
use_armor_filter( IOBUF a )
{
byte buf[1];
int n;
n = iobuf_peek(a, buf, 1 );
if( n == -1 )
return 0; /* EOF, doesn't matter whether armored or not */
if( !n )
return 1; /* can't check it: try armored */
return is_armored(buf);
}
static void
invalid_armor(void)
{
write_status(STATUS_BADARMOR);
g10_exit(1); /* stop here */
}
/****************
* check whether the armor header is valid on a signed message.
* this is for security reasons: the header lines are not included in the
* hash and by using some creative formatting rules, Mallory could fake
* any text at the beginning of a document; assuming it is read with
* a simple viewer. We only allow the Hash Header.
*/
static int
parse_hash_header( const char *line )
{
const char *s, *s2;
unsigned found = 0;
if( strlen(line) < 6 || strlen(line) > 60 )
return 0; /* too short or too long */
if( memcmp( line, "Hash:", 5 ) )
return 0; /* invalid header */
s = line+5;
for(s=line+5;;s=s2) {
for(; *s && (*s==' ' || *s == '\t'); s++ )
;
if( !*s )
break;
for(s2=s+1; *s2 && *s2!=' ' && *s2 != '\t' && *s2 != ','; s2++ )
;
if( !strncmp( s, "RIPEMD160", s2-s ) )
found |= 1;
else if( !strncmp( s, "SHA1", s2-s ) )
found |= 2;
else if( !strncmp( s, "MD5", s2-s ) )
found |= 4;
else if( !strncmp( s, "TIGER", s2-s ) )
found |= 8;
else
return 0;
for(; *s2 && (*s2==' ' || *s2 == '\t'); s2++ )
;
if( *s2 && *s2 != ',' )
return 0;
if( *s2 )
s2++;
}
return found;
}
/****************
* parse an ascii armor.
* Returns: the state,
* the remaining bytes in BUF are returned in RBUFLEN.
* r_empty return the # of empty lines before the buffer
*/
static fhdr_state_t
find_header( fhdr_state_t state, byte *buf, size_t *r_buflen,
IOBUF a, size_t n, unsigned *r_empty, int *r_hashes,
int only_keyblocks, int *not_dashed )
{
int c=0, i;
const char *s;
byte *p;
size_t buflen;
int cont;
int clearsig=0;
int hdr_line=0;
unsigned empty = 0;
buflen = *r_buflen;
assert(buflen >= 100 );
buflen -= 4; /* reserved room for CR,LF, and two extra */
do {
switch( state ) {
case fhdrHASArmor:
/* read at least the first byte to check whether it is armored
* or not */
c = 0;
for(n=0; n < 28 && (c=iobuf_get(a)) != -1 && c != '\n'; )
buf[n++] = c;
if( !n && c == '\n' )
state = fhdrCHECKBegin;
else if( !n || c == -1 )
state = fhdrNOArmor; /* too short */
else if( !is_armored( buf ) ) {
state = fhdrNOArmor;
if( c == '\n' )
buf[n++] = c;
}
else if( c == '\n' )
state = fhdrCHECKBegin;
else
state = fhdrINITCont;
break;
case fhdrINIT: /* read some stuff into buffer */
n = 0;
case fhdrINITCont: /* read more stuff into buffer */
c = 0;
for(; n < buflen && (c=iobuf_get(a)) != -1 && c != '\n'; )
buf[n++] = c;
state = c == '\n' ? fhdrCHECKBegin :
c == -1 ? fhdrEOF : fhdrINITSkip;
break;
case fhdrINITSkip:
if( c == '\n' )
n = 0;
else {
while( (c=iobuf_get(a)) != -1 && c != '\n' )
;
}
state = c == -1? fhdrEOF : fhdrINIT;
break;
case fhdrSKIPHeader:
while( (c=iobuf_get(a)) != -1 && c != '\n' )
;
state = c == -1? fhdrEOF : fhdrWAITHeader;
break;
case fhdrWAITHeader: /* wait for Header lines */
c = 0;
for(n=0; n < buflen && (c=iobuf_get(a)) != -1 && c != '\n'; )
buf[n++] = c;
buf[n] = 0;
if( n < buflen || c == '\n' ) {
if( n && buf[0] != '\r') { /* maybe a header */
if( strchr( buf, ':') ) { /* yes */
int hashes=0;
if( buf[n-1] == '\r' )
buf[--n] = 0;
if( opt.verbose ) {
log_info(_("armor header: "));
print_string( stderr, buf, n, 0 );
putc('\n', stderr);
}
if( clearsig && !(hashes=parse_hash_header( buf )) ) {
if( strlen(buf) > 15
&& !memcmp( buf, "NotDashEscaped:", 15 ) ) {
*not_dashed = 1;
state = fhdrWAITHeader;
}
else {
log_error(_("invalid clearsig header\n"));
state = fhdrERROR;
}
}
else {
state = fhdrWAITHeader;
if( r_hashes )
*r_hashes |= hashes;
}
}
else if( clearsig && n > 15 && !memcmp(buf, "-----", 5 ) )
state = fhdrNullClearsig;
else
state = fhdrCHECKDashEscaped3;
}
else if( !n || (buf[0] == '\r' && !buf[1]) ) { /* empty line */
if( clearsig )
state = fhdrWAITClearsig;
else {
/* this is not really correct: if we do not have
* a clearsig and no armor lines we are not allowed
* to have an empty line */
n = 0;
state = fhdrTEXT;
}
}
else {
log_error(_("invalid armor header: "));
print_string( stderr, buf, n, 0 );
putc('\n', stderr);
state = fhdrERROR;
}
}
else if( c != -1 ) {
if( strchr( buf, ':') ) { /* buffer to short, but this is okay*/
if( opt.verbose ) {
log_info(_("armor header: "));
print_string( stderr, buf, n, 0 );
fputs("[...]\n", stderr); /* indicate it is truncated */
}
state = fhdrSKIPHeader; /* skip rest of line */
}
else /* line too long */
state = fhdrERROR;
}
else
state = fhdrEOF;
break;
case fhdrWAITClearsig: /* skip the empty line (for clearsig) */
c = 0;
for(n=0; n < buflen && (c=iobuf_get(a)) != -1 && c != '\n'; )
buf[n++] = c;
if( c != -1 ) {
if( n > 15 && !memcmp(buf, "-----", 5 ) )
state = fhdrNullClearsig;
else if( c != '\n' )
state = fhdrREADClearsigNext;
else
state = fhdrCHECKDashEscaped3;
}
else {
/* fixme: we should check whether this line continues
* it is possible that we have only read ws until here
* and more stuff is to come */
state = fhdrEOF;
}
break;
case fhdrNullClearsig: /* zero length cleartext */
state = fhdrENDClearsig;
break;
case fhdrENDClearsig:
case fhdrCHECKBegin:
state = state == fhdrCHECKBegin ? fhdrINITSkip : fhdrERRORShow;
if( n < 15 )
break; /* too short */
if( memcmp( buf, "-----", 5 ) )
break;
buf[n] = 0;
p = strstr(buf+5, "-----");
if( !p )
break;
*p = 0;
p += 5;
if( *p == '\r' )
p++;
if( *p )
break; /* garbage after dashes */
p = buf+5;
for(i=0; (s=head_strings[i]); i++ )
if( !strcmp(s, p) )
break;
if( !s )
break; /* unknown begin line */
if( only_keyblocks && i != 1 && i != 5 && i != 6 )
break; /* not a keyblock armor */
/* found the begin line */
hdr_line = i;
state = fhdrWAITHeader;
if( hdr_line == BEGIN_SIGNED_MSG_IDX )
clearsig = 1;
if( opt.verbose > 1 )
log_info(_("armor: %s\n"), head_strings[hdr_line]);
break;
case fhdrCLEARSIGSimple:
/* we are at the begin of a new line */
case fhdrCLEARSIGSimpleNext:
n = 0;
c = 0;
while( n < buflen && (c=iobuf_get(a)) != -1 ) {
buf[n++] = c;
if( c == '\n' )
break;
}
buf[n] = 0;
if( c == -1 )
state = fhdrEOF;
else if( state == fhdrCLEARSIGSimple
&& n > 15 && !memcmp(buf, "-----", 5 ) ) {
if( c == '\n' )
buf[n-1] = 0;
state = fhdrENDClearsig;
}
else if( c == '\n' )
state = fhdrCLEARSIGSimple;
else
state = fhdrCLEARSIGSimpleNext;
break;
case fhdrCLEARSIG:
case fhdrEMPTYClearsig:
case fhdrREADClearsig:
/* we are at the start of a line: read a clearsig into the buffer
* we have to look for a header line or dashed escaped text*/
n = 0;
c = 0;
while( n < buflen && (c=iobuf_get(a)) != -1 && c != '\n' )
buf[n++] = c;
buf[n] = 0;
if( c == -1 )
state = fhdrEOF;
else if( !n || ( buf[0]=='\r' && !buf[1] ) ) {
state = fhdrEMPTYClearsig;
empty++;
}
else if( c == '\n' )
state = fhdrCHECKClearsig2;
else
state = fhdrCHECKClearsig;
break;
case fhdrCHECKDashEscaped3:
if( *not_dashed ) {
state = fhdrTEXTSimple;
break;
}
if( !(n > 1 && buf[0] == '-' && buf[1] == ' ' ) ) {
state = fhdrTEXT;
break;
}
/* fall through */
case fhdrCHECKDashEscaped2:
case fhdrCHECKDashEscaped:
/* check dash escaped line */
if( buf[2] == '-' || ( n > 6 && !memcmp(buf+2, "From ", 5))) {
for(i=2; i < n; i++ )
buf[i-2] = buf[i];
n -= 2;
buf[n] = 0; /* not really needed */
state = state == fhdrCHECKDashEscaped3 ? fhdrTEXT :
state == fhdrCHECKDashEscaped2 ?
fhdrREADClearsig : fhdrTESTSpaces;
}
else {
log_error(_("invalid dash escaped line: "));
print_string( stderr, buf, n, 0 );
putc('\n', stderr);
state = fhdrERROR;
}
break;
case fhdrCHECKClearsig:
/* check the clearsig line */
if( n > 15 && !memcmp(buf, "-----", 5 ) )
state = fhdrENDClearsig;
else if( buf[0] == '-' && buf[1] == ' ' && !*not_dashed )
state = fhdrCHECKDashEscaped;
else {
state = fhdrTESTSpaces;
}
break;
case fhdrCHECKClearsig2:
/* check the clearsig line */
if( n > 15 && !memcmp(buf, "-----", 5 ) )
state = fhdrENDClearsig;
else if( buf[0] == '-' && buf[1] == ' ' && !*not_dashed )
state = fhdrCHECKDashEscaped2;
else {
state = fhdrREADClearsig;
}
break;
case fhdrREADClearsigNext:
/* Read to the end of the line, do not care about checking
* for dashed escaped text of headers */
c = 0;
n = 0;
while( n < buflen && (c=iobuf_get(a)) != -1 && c != '\n' )
buf[n++] = c;
buf[n] = 0;
if( c == -1 )
state = fhdrEOF;
else if( c == '\n' )
state = fhdrREADClearsig;
else
state = fhdrTESTSpaces;
break;
case fhdrTESTSpaces: {
/* but must check whether the rest of the line
* only contains white spaces; this is problematic
* since we may have to restore the stuff. simply
* counting spaces is not enough, because it may be a
* mix of different white space characters */
IOBUF b = iobuf_temp();
while( (c=iobuf_get(a)) != -1 && c != '\n' ) {
iobuf_put(b,c);
if( c != ' ' && c != '\t' && c != '\r' )
break;
}
if( c == '\n' ) {
/* okay we can skip the rest of the line */
iobuf_close(b);
state = fhdrREADClearsig;
}
else {
iobuf_unget_and_close_temp(a,b);
state = fhdrREADClearsigNext;
}
} break;
case fhdrERRORShow:
log_error(_("invalid clear text header: "));
print_string( stderr, buf, n, 0 );
putc('\n', stderr);
state = fhdrERROR;
break;
default: BUG();
}
switch( state ) {
case fhdrINIT:
case fhdrINITCont:
case fhdrINITSkip:
case fhdrCHECKBegin:
case fhdrWAITHeader:
case fhdrWAITClearsig:
case fhdrSKIPHeader:
case fhdrEMPTYClearsig:
case fhdrCHECKClearsig:
case fhdrCHECKClearsig2:
case fhdrCHECKDashEscaped:
case fhdrCHECKDashEscaped2:
case fhdrCHECKDashEscaped3:
case fhdrTESTSpaces:
case fhdrERRORShow:
cont = 1;
break;
default: cont = 0;
}
} while( cont );
if( clearsig && state == fhdrTEXT )
state = fhdrCLEARSIG;
else if( clearsig && state == fhdrTEXTSimple ) {
state = fhdrCLEARSIGSimple;
buf[n] = '\n';
n++;
}
if( state == fhdrCLEARSIG || state == fhdrREADClearsig ) {
/* append CR,LF after removing trailing wspaces */
for(p=buf+n-1; n; n--, p-- ) {
assert( *p != '\n' );
if( *p != ' ' && *p != '\t' && *p != '\r' ) {
p[1] = '\r';
p[2] = '\n';
n += 2;
break;
}
}
if( !n ) {
buf[0] = '\r';
buf[1] = '\n';
n = 2;
}
}
*r_buflen = n;
*r_empty = empty;
return state;
}
/* figure out whether the data is armored or not */
static int
check_input( armor_filter_context_t *afx, IOBUF a )
{
int rc = 0;
size_t n;
fhdr_state_t state = afx->parse_state;
unsigned emplines;
if( state != fhdrENDClearsig )
state = fhdrHASArmor;
n = DIM(afx->helpbuf);
state = find_header( state, afx->helpbuf, &n, a,
afx->helplen, &emplines, &afx->hashes,
afx->only_keyblocks, &afx->not_dash_escaped );
switch( state ) {
case fhdrNOArmor:
afx->inp_checked = 1;
afx->inp_bypass = 1;
afx->helplen = n;
break;
case fhdrERROR:
invalid_armor();
break;
case fhdrEOF:
rc = -1;
break;
case fhdrNullClearsig:
case fhdrCLEARSIG: /* start fake package mode (for clear signatures) */
case fhdrREADClearsigNext:
case fhdrCLEARSIGSimple:
case fhdrCLEARSIGSimpleNext:
afx->helplen = n;
afx->helpidx = 0;
afx->faked = 1;
break;
case fhdrTEXT:
afx->helplen = n;
afx->helpidx = 0;
afx->inp_checked = 1;
afx->crc = CRCINIT;
afx->idx = 0;
afx->radbuf[0] = 0;
break;
default: BUG();
}
afx->parse_state = state;
return rc;
}
/* fake a literal data packet and wait for an armor line */
static int
fake_packet( armor_filter_context_t *afx, IOBUF a,
size_t *retn, byte *buf, size_t size )
{
int rc = 0;
size_t len = 0;
size_t n, nn;
fhdr_state_t state = afx->parse_state;
unsigned emplines = afx->empty;
len = 2; /* reserve 2 bytes for the length header */
size -= 3; /* and 1 for empline handling and 2 for the term header */
while( !rc && len < size ) {
if( emplines ) {
while( emplines && len < size ) {
buf[len++] = '\r';
buf[len++] = '\n';
emplines--;
}
continue;
}
if( state == fhdrENDClearsigHelp ) {
state = fhdrENDClearsig;
afx->faked = 0;
rc = -1;
continue;
}
if( state != fhdrNullClearsig
&& afx->helpidx < afx->helplen ) { /* flush the last buffer */
n = afx->helplen;
for(nn=afx->helpidx; len < size && nn < n ; nn++ )
buf[len++] = afx->helpbuf[nn];
afx->helpidx = nn;
continue;
}
if( state == fhdrEOF ) {
rc = -1;
continue;
}
/* read a new one */
n = DIM(afx->helpbuf);
afx->helpidx = 0;
state = find_header( state, afx->helpbuf, &n, a,
state == fhdrNullClearsig? afx->helplen:0,
&emplines, &afx->hashes,
afx->only_keyblocks,
&afx->not_dash_escaped );
switch( state) {
case fhdrERROR:
invalid_armor();
break;
case fhdrEOF:
rc = -1;
break;
case fhdrCLEARSIG:
BUG();
case fhdrREADClearsig:
case fhdrREADClearsigNext:
case fhdrCLEARSIGSimple:
case fhdrCLEARSIGSimpleNext:
afx->helplen = n;
break;
case fhdrENDClearsig:
state = fhdrENDClearsigHelp;
afx->helplen = n;
break;
default: BUG();
}
}
buf[0] = (len-2) >> 8;
buf[1] = (len-2);
if( state == fhdrENDClearsig ) { /* write last (ending) length header */
if( buf[0] || buf[1] ) { /* write only if length of text is > 0 */
buf[len++] = 0;
buf[len++] = 0;
}
rc = 0;
}
afx->parse_state = state;
afx->empty = emplines;
*retn = len;
return rc;
}
static int
radix64_read( armor_filter_context_t *afx, IOBUF a, size_t *retn,
byte *buf, size_t size )
{
byte val;
int c, c2;
int checkcrc=0;
int rc = 0;
size_t n = 0;
int idx, i;
u32 crc;
crc = afx->crc;
idx = afx->idx;
val = afx->radbuf[0];
for( n=0; n < size; ) {
if( afx->helpidx < afx->helplen )
c = afx->helpbuf[afx->helpidx++];
else if( (c=iobuf_get(a)) == -1 )
break;
if( c == '\n' || c == ' ' || c == '\r' || c == '\t' )
continue;
else if( c == '=' ) { /* pad character: stop */
if( idx == 1 )
buf[n++] = val;
checkcrc++;
break;
}
else if( (c = asctobin[(c2=c)]) == 255 ) {
log_error(_("invalid radix64 character %02x skipped\n"), c2);
continue;
}
switch(idx) {
case 0: val = c << 2; break;
case 1: val |= (c>>4)&3; buf[n++]=val;val=(c<<4)&0xf0;break;
case 2: val |= (c>>2)&15; buf[n++]=val;val=(c<<6)&0xc0;break;
case 3: val |= c&0x3f; buf[n++] = val; break;
}
idx = (idx+1) % 4;
}
for(i=0; i < n; i++ )
crc = (crc << 8) ^ crc_table[((crc >> 16)&0xff) ^ buf[i]];
crc &= 0x00ffffff;
afx->crc = crc;
afx->idx = idx;
afx->radbuf[0] = val;
if( checkcrc ) {
afx->any_data = 1;
afx->inp_checked=0;
afx->faked = 0;
afx->parse_state = 0;
for(;;) { /* skip lf and pad characters */
if( afx->helpidx < afx->helplen )
c = afx->helpbuf[afx->helpidx++];
else if( (c=iobuf_get(a)) == -1 )
break;
if( c == '\n' || c == ' ' || c == '\r'
|| c == '\t' || c == '=' )
continue;
break;
}
if( c == -1 )
log_error(_("premature eof (no CRC)\n"));
else {
u32 mycrc = 0;
idx = 0;
do {
if( (c = asctobin[c]) == 255 )
break;
switch(idx) {
case 0: val = c << 2; break;
case 1: val |= (c>>4)&3; mycrc |= val << 16;val=(c<<4)&0xf0;break;
case 2: val |= (c>>2)&15; mycrc |= val << 8;val=(c<<6)&0xc0;break;
case 3: val |= c&0x3f; mycrc |= val; break;
}
if( afx->helpidx < afx->helplen )
c = afx->helpbuf[afx->helpidx++];
else if( (c=iobuf_get(a)) == -1 )
break;
} while( ++idx < 4 );
if( c == -1 ) {
log_error(_("premature eof (in CRC)\n"));
rc = G10ERR_INVALID_ARMOR;
}
else if( idx != 4 ) {
log_error(_("malformed CRC\n"));
rc = G10ERR_INVALID_ARMOR;
}
else if( mycrc != afx->crc ) {
log_error(_("CRC error; %06lx - %06lx\n"),
(ulong)afx->crc, (ulong)mycrc);
rc = G10ERR_INVALID_ARMOR;
}
else {
rc = 0;
#if 0
for(rc=0;!rc;) {
rc = 0 /*check_trailer( &fhdr, c )*/;
if( !rc ) {
if( afx->helpidx < afx->helplen )
c = afx->helpbuf[afx->helpidx++];
else if( (c=iobuf_get(a)) == -1 )
rc = 2;
}
}
if( rc == -1 )
rc = 0;
else if( rc == 2 ) {
log_error(_("premature eof (in Trailer)\n"));
rc = G10ERR_INVALID_ARMOR;
}
else {
log_error(_("error in trailer line\n"));
rc = G10ERR_INVALID_ARMOR;
}
#endif
}
}
}
if( !n )
rc = -1;
*retn = n;
return rc;
}
/****************
* This filter is used to handle the armor stuff
*/
int
armor_filter( void *opaque, int control,
IOBUF a, byte *buf, size_t *ret_len)
{
size_t size = *ret_len;
armor_filter_context_t *afx = opaque;
int rc=0, i, c;
byte radbuf[3];
int idx, idx2;
size_t n=0;
u32 crc;
#if 0
static FILE *fp ;
if( !fp ) {
fp = fopen("armor.out", "w");
assert(fp);
}
#endif
if( DBG_FILTER )
log_debug("armor-filter: control: %d\n", control );
if( control == IOBUFCTRL_UNDERFLOW && afx->inp_bypass ) {
for( n=0; n < size; n++ ) {
if( (c=iobuf_get(a)) == -1 )
break;
buf[n] = c & 0xff;
}
if( !n )
rc = -1;
*ret_len = n;
}
else if( control == IOBUFCTRL_UNDERFLOW ) {
if( size < 15+(4*15) ) /* need space for up to 4 onepass_sigs */
BUG(); /* supplied buffer too short */
if( afx->faked )
rc = fake_packet( afx, a, &n, buf, size );
else if( !afx->inp_checked ) {
rc = check_input( afx, a );
if( afx->inp_bypass ) {
for( n=0; n < size && n < afx->helplen; n++ )
buf[n] = afx->helpbuf[n];
if( !n )
rc = -1;
assert( n == afx->helplen );
afx->helplen = 0;
}
else if( afx->faked ) {
unsigned hashes = afx->hashes;
/* the buffer is at least 15+n*15 bytes long, so it
* is easy to construct the packets */
hashes &= 1|2|4|8;
if( !hashes )
hashes |= 4; /* default to MD 5 */
n=0;
do {
/* first some onepass signature packets */
buf[n++] = 0x90; /* old format, type 4, 1 length byte */
buf[n++] = 13; /* length */
buf[n++] = 3; /* version */
buf[n++] = 0x01; /* sigclass 0x01 (canonical text mode)*/
if( hashes & 1 ) {
hashes &= ~1;
buf[n++] = DIGEST_ALGO_RMD160;
}
else if( hashes & 2 ) {
hashes &= ~2;
buf[n++] = DIGEST_ALGO_SHA1;
}
else if( hashes & 4 ) {
hashes &= ~4;
buf[n++] = DIGEST_ALGO_MD5;
}
else if( hashes & 8 ) {
hashes &= ~8;
buf[n++] = DIGEST_ALGO_TIGER;
}
else
buf[n++] = 0; /* (don't know) */
buf[n++] = 0; /* public key algo (don't know) */
memset(buf+n, 0, 8); /* don't know the keyid */
n += 8;
buf[n++] = !hashes; /* last one */
} while( hashes );
/* followed by a plaintext packet */
buf[n++] = 0xaf; /* old packet format, type 11, var length */
buf[n++] = 0; /* set the length header */
buf[n++] = 6;
buf[n++] = 't'; /* canonical text mode */
buf[n++] = 0; /* namelength */
memset(buf+n, 0, 4); /* timestamp */
n += 4;
}
else if( !rc )
rc = radix64_read( afx, a, &n, buf, size );
}
else
rc = radix64_read( afx, a, &n, buf, size );
#if 0
if( n )
if( fwrite(buf, n, 1, fp ) != 1 )
BUG();
#endif
*ret_len = n;
}
else if( control == IOBUFCTRL_FLUSH ) {
if( !afx->status ) { /* write the header line */
if( afx->what >= DIM(head_strings) )
log_bug("afx->what=%d", afx->what);
iobuf_writestr(a, "-----");
iobuf_writestr(a, head_strings[afx->what] );
iobuf_writestr(a, "-----\n");
iobuf_writestr(a, "Version: GnuPG v" VERSION " ("
PRINTABLE_OS_NAME ")\n");
if( opt.comment_string ) {
const char *s = opt.comment_string;
iobuf_writestr(a, "Comment: " );
for( ; *s; s++ ) {
if( *s == '\n' )
iobuf_writestr(a, "\\n" );
else if( *s == '\r' )
iobuf_writestr(a, "\\r" );
else if( *s == '\v' )
iobuf_writestr(a, "\\v" );
else
iobuf_put(a, *s );
}
iobuf_put(a, '\n' );
}
else
iobuf_writestr(a,
- "Comment: For info finger gcrypt@ftp.guug.de\n");
+ "Comment: For info see www.gnupg.org");
if( afx->hdrlines )
iobuf_writestr(a, afx->hdrlines);
iobuf_put(a, '\n');
afx->status++;
afx->idx = 0;
afx->idx2 = 0;
afx->crc = CRCINIT;
}
crc = afx->crc;
idx = afx->idx;
idx2 = afx->idx2;
for(i=0; i < idx; i++ )
radbuf[i] = afx->radbuf[i];
for(i=0; i < size; i++ )
crc = (crc << 8) ^ crc_table[((crc >> 16)&0xff) ^ buf[i]];
crc &= 0x00ffffff;
for( ; size; buf++, size-- ) {
radbuf[idx++] = *buf;
if( idx > 2 ) {
idx = 0;
c = bintoasc[(*radbuf >> 2) & 077];
iobuf_put(a, c);
c = bintoasc[(((*radbuf<<4)&060)|((radbuf[1] >> 4)&017))&077];
iobuf_put(a, c);
c = bintoasc[(((radbuf[1]<<2)&074)|((radbuf[2]>>6)&03))&077];
iobuf_put(a, c);
c = bintoasc[radbuf[2]&077];
iobuf_put(a, c);
if( ++idx2 >= (64/4) ) { /* pgp doesn't like 72 here */
iobuf_put(a, '\n');
idx2=0;
}
}
}
for(i=0; i < idx; i++ )
afx->radbuf[i] = radbuf[i];
afx->idx = idx;
afx->idx2 = idx2;
afx->crc = crc;
}
else if( control == IOBUFCTRL_INIT ) {
if( !is_initialized )
initialize();
}
else if( control == IOBUFCTRL_FREE ) {
if( afx->status ) { /* pad, write cecksum, and bottom line */
crc = afx->crc;
idx = afx->idx;
idx2 = afx->idx2;
for(i=0; i < idx; i++ )
radbuf[i] = afx->radbuf[i];
if( idx ) {
c = bintoasc[(*radbuf>>2)&077];
iobuf_put(a, c);
if( idx == 1 ) {
c = bintoasc[((*radbuf << 4) & 060) & 077];
iobuf_put(a, c);
iobuf_put(a, '=');
iobuf_put(a, '=');
}
else { /* 2 */
c = bintoasc[(((*radbuf<<4)&060)|((radbuf[1]>>4)&017))&077];
iobuf_put(a, c);
c = bintoasc[((radbuf[1] << 2) & 074) & 077];
iobuf_put(a, c);
iobuf_put(a, '=');
}
if( ++idx2 >= (64/4) ) { /* pgp doesn't like 72 here */
iobuf_put(a, '\n');
idx2=0;
}
}
/* may need a linefeed */
if( idx2 )
iobuf_put(a, '\n');
/* write the CRC */
iobuf_put(a, '=');
radbuf[0] = crc >>16;
radbuf[1] = crc >> 8;
radbuf[2] = crc;
c = bintoasc[(*radbuf >> 2) & 077];
iobuf_put(a, c);
c = bintoasc[(((*radbuf<<4)&060)|((radbuf[1] >> 4)&017))&077];
iobuf_put(a, c);
c = bintoasc[(((radbuf[1]<<2)&074)|((radbuf[2]>>6)&03))&077];
iobuf_put(a, c);
c = bintoasc[radbuf[2]&077];
iobuf_put(a, c);
iobuf_put(a, '\n');
/* and the the trailer */
if( afx->what >= DIM(tail_strings) )
log_bug("afx->what=%d", afx->what);
iobuf_writestr(a, "-----");
iobuf_writestr(a, tail_strings[afx->what] );
iobuf_writestr(a, "-----\n");
}
else if( !afx->any_data && !afx->inp_bypass )
log_error(_("no valid RFC1991 or OpenPGP data found.\n"));
}
else if( control == IOBUFCTRL_DESC )
*(char**)buf = "armor_filter";
return rc;
}
diff --git a/g10/g10.c b/g10/g10.c
index b2c96e565..1f1fed5e5 100644
--- a/g10/g10.c
+++ b/g10/g10.c
@@ -1,1428 +1,1435 @@
/* g10.c - The GnuPG utility (main for gpg)
* Copyright (C) 1998 Free Software Foundation, Inc.
*
* This file is part of GNUPG.
*
* GNUPG 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.
*
* GNUPG 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 <errno.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <ctype.h>
#include <unistd.h>
#define MAINTAINER_OPTIONS
#include "packet.h"
#include "iobuf.h"
#include "memory.h"
#include "util.h"
#include "main.h"
#include "options.h"
#include "keydb.h"
#include "mpi.h"
#include "cipher.h"
#include "filter.h"
#include "trustdb.h"
#include "ttyio.h"
#include "i18n.h"
#include "status.h"
#include "g10defs.h"
#ifndef IS_G10MAINT
#define IS_G10 1
#endif
enum cmd_and_opt_values { aNull = 0,
oArmor = 'a',
aDetachedSign = 'b',
aSym = 'c',
aDecrypt = 'd',
aEncr = 'e',
oKOption = 'k',
oDryRun = 'n',
oOutput = 'o',
oQuiet = 'q',
oRemote = 'r',
aSign = 's',
oTextmodeShort= 't',
oUser = 'u',
oVerbose = 'v',
oCompress = 'z',
oBatch = 500,
aClearsign,
aStore,
aKeygen,
aSignEncr,
aSignKey,
aListPackets,
aEditKey,
aDeleteKey,
aDeleteSecretKey,
aKMode,
aKModeC,
aImport,
aFastImport,
aVerify,
aListKeys,
aListSigs,
aListSecretKeys,
aExport,
aExportAll,
aExportSecret,
aCheckKeys,
aGenRevoke,
aPrimegen,
aPrintMD,
aPrintMDs,
aCheckTrustDB,
aUpdateTrustDB,
aFixTrustDB,
aListTrustDB,
aListTrustPath,
aExportOwnerTrust,
aImportOwnerTrust,
aDeArmor,
aEnArmor,
aGenRandom,
oTextmode,
oFingerprint,
oAnswerYes,
oAnswerNo,
oKeyring,
oSecretKeyring,
oDefaultKey,
oTrustedKey,
oOptions,
oDebug,
oDebugAll,
oStatusFD,
oNoComment,
oCompletesNeeded,
oMarginalsNeeded,
oMaxCertDepth,
oLoadExtension,
oRFC1991,
oCipherAlgo,
oDigestAlgo,
oCompressAlgo,
oPasswdFD,
oQuickRandom,
oNoVerbose,
oTrustDBName,
oNoSecmemWarn,
oNoArmor,
oNoDefKeyring,
oNoGreeting,
oNoOptions,
oNoBatch,
oHomedir,
oWithColons,
oSkipVerify,
oCompressKeys,
oCompressSigs,
oAlwaysTrust,
oEmuChecksumBug,
oRunAsShmCP,
oSetFilename,
oComment,
oThrowKeyid,
oForceV3Sigs,
oS2KMode,
oS2KDigest,
oS2KCipher,
oCharset,
oNotDashEscaped,
+ oEscapeFrom,
oLockOnce,
aTest };
static ARGPARSE_OPTS opts[] = {
{ 300, NULL, 0, N_("@Commands:\n ") },
#ifdef IS_G10
{ aSign, "sign", 256, N_("|[file]|make a signature")},
{ aClearsign, "clearsign", 256, N_("|[file]|make a clear text signature") },
{ aDetachedSign, "detach-sign", 256, N_("make a detached signature")},
{ aEncr, "encrypt", 256, N_("encrypt data")},
{ aSym, "symmetric", 256, N_("encryption only with symmetric cipher")},
{ aStore, "store", 256, N_("store only")},
{ aDecrypt, "decrypt", 256, N_("decrypt data (default)")},
{ aVerify, "verify" , 256, N_("verify a signature")},
#endif
{ aListKeys, "list-keys", 256, N_("list keys")},
{ aListSigs, "list-sigs", 256, N_("list keys and signatures")},
{ aCheckKeys, "check-sigs",256, N_("check key signatures")},
{ oFingerprint, "fingerprint", 256, N_("list keys and fingerprints")},
{ aListSecretKeys, "list-secret-keys", 256, N_("list secret keys")},
#ifdef IS_G10
{ aKeygen, "gen-key", 256, N_("generate a new key pair")},
#endif
{ aDeleteKey, "delete-key",256, N_("remove key from the public keyring")},
#ifdef IS_G10
{ aEditKey, "edit-key" ,256, N_("sign or edit a key")},
{ aGenRevoke, "gen-revoke",256, N_("generate a revocation certificate")},
#endif
{ aExport, "export" , 256, N_("export keys") },
{ aExportAll, "export-all" , 256, "@" },
{ aExportSecret, "export-secret-keys" , 256, "@" },
{ aImport, "import", 256 , N_("import/merge keys")},
{ aFastImport, "fast-import", 256 , "@"},
{ aListPackets, "list-packets",256,N_("list only the sequence of packets")},
#ifdef IS_G10MAINT
{ aExportOwnerTrust,
"export-ownertrust", 256, N_("export the ownertrust values")},
{ aImportOwnerTrust,
"import-ownertrust", 256 , N_("import ownertrust values")},
{ aUpdateTrustDB,
"update-trustdb",0 , N_("|[NAMES]|update the trust database")},
{ aCheckTrustDB,
"check-trustdb",0 , N_("|[NAMES]|check the trust database")},
{ aFixTrustDB, "fix-trustdb",0 , N_("fix a corrupted trust database")},
{ aDeArmor, "dearmor", 256, N_("De-Armor a file or stdin") },
{ aEnArmor, "enarmor", 256, N_("En-Armor a file or stdin") },
{ aPrintMD, "print-md" , 256, N_("|algo [files]|print message digests")},
{ aPrintMDs, "print-mds" , 256, N_("print all message digests")},
#ifdef MAINTAINER_OPTIONS
{ aPrimegen, "gen-prime" , 256, "@" },
{ aGenRandom, "gen-random" , 256, "@" },
#endif
#endif
{ 301, NULL, 0, N_("@\nOptions:\n ") },
{ oArmor, "armor", 0, N_("create ascii armored output")},
#ifdef IS_G10
{ oUser, "local-user",2, N_("use this user-id to sign or decrypt")},
{ oRemote, "remote-user", 2, N_("use this user-id for encryption")},
{ oCompress, NULL, 1, N_("|N|set compress level N (0 disables)") },
{ oTextmodeShort, NULL, 0, "@"},
{ oTextmode, "textmode", 0, N_("use canonical text mode")},
#endif
{ oOutput, "output", 2, N_("use as output file")},
{ oVerbose, "verbose", 0, N_("verbose") },
{ oQuiet, "quiet", 0, N_("be somewhat more quiet") },
{ oForceV3Sigs, "force-v3-sigs", 0, N_("force v3 signatures") },
/* { oDryRun, "dry-run", 0, N_("do not make any changes") }, */
{ oBatch, "batch", 0, N_("batch mode: never ask")},
{ oAnswerYes, "yes", 0, N_("assume yes on most questions")},
{ oAnswerNo, "no", 0, N_("assume no on most questions")},
{ oKeyring, "keyring" ,2, N_("add this keyring to the list of keyrings")},
{ oSecretKeyring, "secret-keyring" ,2, N_("add this secret keyring to the list")},
{ oDefaultKey, "default-key" ,2, N_("|NAME|use NAME as default secret key")},
{ oCharset, "charset" , 2, N_("|NAME|set terminal charset to NAME") },
{ oOptions, "options" , 2, N_("read options from file")},
{ oDebug, "debug" ,4|16, N_("set debugging flags")},
{ oDebugAll, "debug-all" ,0, N_("enable full debugging")},
{ oStatusFD, "status-fd" ,1, N_("|FD|write status info to this FD") },
{ oNoComment, "no-comment", 0, N_("do not write comment packets")},
{ oCompletesNeeded, "completes-needed", 1, N_("(default is 1)")},
{ oMarginalsNeeded, "marginals-needed", 1, N_("(default is 3)")},
{ oMaxCertDepth, "max-cert-depth", 1, "@" },
{ oTrustedKey, "trusted-key", 2, N_("|KEYID|ulimately trust this key")},
{ oLoadExtension, "load-extension" ,2, N_("|FILE|load extension module FILE")},
{ oRFC1991, "rfc1991", 0, N_("emulate the mode described in RFC1991")},
{ oS2KMode, "s2k-mode", 1, N_("|N|use passphrase mode N")},
{ oS2KDigest, "s2k-digest-algo",2,
N_("|NAME|use message digest algorithm NAME for passphrases")},
{ oS2KCipher, "s2k-cipher-algo",2,
N_("|NAME|use cipher algorithm NAME for passphrases")},
#ifdef IS_G10
{ oCipherAlgo, "cipher-algo", 2 , N_("|NAME|use cipher algorithm NAME")},
{ oDigestAlgo, "digest-algo", 2 , N_("|NAME|use message digest algorithm NAME")},
{ oCompressAlgo, "compress-algo", 1 , N_("|N|use compress algorithm N")},
{ oThrowKeyid, "throw-keyid", 0, N_("throw keyid field of encrypted packets")},
#else /* some dummies */
{ oCipherAlgo, "cipher-algo", 2 , "@"},
{ oDigestAlgo, "digest-algo", 2 , "@"},
{ oCompressAlgo, "compress-algo", 1 , "@"},
#endif
#ifdef IS_G10
{ 302, NULL, 0, N_("@\nExamples:\n\n"
" -se -r Bob [file] sign and encrypt for user Bob\n"
" --clearsign [file] make a clear text signature\n"
" --detach-sign [file] make a detached signature\n"
" --list-keys [names] show keys\n"
" --fingerprint [names] show fingerprints\n" ) },
#endif
/* hidden options */
#ifdef IS_G10MAINT
{ aExportOwnerTrust, "list-ownertrust",0 , "@"}, /* alias */
{ aListTrustDB, "list-trustdb",0 , "@"},
{ aListTrustPath, "list-trust-path",0, "@"},
#endif
#ifdef IS_G10
{ oKOption, NULL, 0, "@"},
{ oPasswdFD, "passphrase-fd",1, "@" },
{ aSignKey, "sign-key" ,256, "@" }, /* alias for edit-key */
#endif
{ aDeleteSecretKey, "delete-secret-key",0, "@" },
{ oQuickRandom, "quick-random", 0, "@"},
{ oNoVerbose, "no-verbose", 0, "@"},
{ oTrustDBName, "trustdb-name", 2, "@" },
{ oNoSecmemWarn, "no-secmem-warning", 0, "@" }, /* used only by regression tests */
{ oNoArmor, "no-armor", 0, "@"},
{ oNoDefKeyring, "no-default-keyring", 0, "@" },
{ oNoGreeting, "no-greeting", 0, "@" },
{ oNoOptions, "no-options", 0, "@" }, /* shortcut for --options /dev/null */
{ oHomedir, "homedir", 2, "@" }, /* defaults to "~/.gnupg" */
{ oNoBatch, "no-batch", 0, "@" },
{ oWithColons, "with-colons", 0, "@"},
{ aListKeys, "list-key", 0, "@" }, /* alias */
{ aListSigs, "list-sig", 0, "@" }, /* alias */
{ aCheckKeys, "check-sig",0, "@" }, /* alias */
{ oSkipVerify, "skip-verify",0, "@" },
{ oCompressKeys, "compress-keys",0, "@"},
{ oCompressSigs, "compress-sigs",0, "@"},
{ oAlwaysTrust, "always-trust", 0, "@"},
{ oEmuChecksumBug, "emulate-checksum-bug", 0, "@"},
{ oRunAsShmCP, "run-as-shm-coprocess", 4, "@" },
{ oSetFilename, "set-filename", 2, "@" },
{ oComment, "comment", 2, "@" },
{ oNotDashEscaped, "not-dash-escaped", 0, "@" },
+ { oEscapeFrom, "escape-from-lines", 0, "@" },
{ oLockOnce, "lock-once", 0, "@" },
{0} };
int g10_errors_seen = 0;
static int maybe_setuid = 1;
static char *build_list( const char *text,
const char *(*mapf)(int), int (*chkf)(int) );
static void set_cmd( enum cmd_and_opt_values *ret_cmd,
enum cmd_and_opt_values new_cmd );
#ifdef IS_G10MAINT
static void print_hex( byte *p, size_t n );
static void print_mds( const char *fname, int algo );
#endif
const char *
strusage( int level )
{
static char *digests, *pubkeys, *ciphers;
const char *p;
switch( level ) {
case 11: p =
#ifdef IS_G10MAINT
"gpgm (GnuPG)";
#else
"gpg (GnuPG)";
#endif
break;
case 13: p = VERSION; break;
case 17: p = PRINTABLE_OS_NAME; break;
case 19: p =
_("Please report bugs to <gnupg-bugs@gnu.org>.\n");
break;
case 1:
case 40: p =
#ifdef IS_G10MAINT
_("Usage: gpgm [options] [files] (-h for help)");
#else
_("Usage: gpg [options] [files] (-h for help)");
#endif
break;
case 41: p =
#ifdef IS_G10MAINT
_("Syntax: gpgm [options] [files]\n"
"GnuPG maintenance utility\n");
#else
_("Syntax: gpg [options] [files]\n"
"sign, check, encrypt or decrypt\n"
"default operation depends on the input data\n");
#endif
break;
case 31: p = _("\nSupported algorithms:\n"); break;
case 32:
if( !ciphers )
ciphers = build_list("Cipher: ", cipher_algo_to_string,
check_cipher_algo );
p = ciphers;
break;
case 33:
if( !pubkeys )
pubkeys = build_list("Pubkey: ", pubkey_algo_to_string,
check_pubkey_algo );
p = pubkeys;
break;
case 34:
if( !digests )
digests = build_list("Hash: ", digest_algo_to_string,
check_digest_algo );
p = digests;
break;
default: p = default_strusage(level);
}
return p;
}
static char *
build_list( const char *text, const char * (*mapf)(int), int (*chkf)(int) )
{
int i;
const char *s;
size_t n=strlen(text)+2;
char *list, *p;
if( maybe_setuid )
secmem_init( 0 ); /* drop setuid */
for(i=1; i < 110; i++ )
if( !chkf(i) && (s=mapf(i)) )
n += strlen(s) + 2;
list = m_alloc( 21 + n ); *list = 0;
for(p=NULL, i=1; i < 110; i++ ) {
if( !chkf(i) && (s=mapf(i)) ) {
if( !p )
p = stpcpy( list, text );
else
p = stpcpy( p, ", ");
p = stpcpy(p, s );
}
}
if( p )
p = stpcpy(p, "\n" );
return list;
}
static void
i18n_init(void)
{
#ifdef ENABLE_NLS
#ifdef HAVE_LC_MESSAGES
setlocale( LC_TIME, "" );
setlocale( LC_MESSAGES, "" );
#else
setlocale( LC_ALL, "" );
#endif
bindtextdomain( PACKAGE, G10_LOCALEDIR );
textdomain( PACKAGE );
#endif
}
static void
wrong_args( const char *text)
{
#ifdef IS_G10MAINT
fputs(_("usage: gpgm [options] "),stderr);
#else
fputs(_("usage: gpg [options] "),stderr);
#endif
fputs(text,stderr);
putc('\n',stderr);
g10_exit(2);
}
static void
set_debug(void)
{
if( opt.debug & DBG_MEMORY_VALUE )
memory_debug_mode = 1;
if( opt.debug & DBG_MEMSTAT_VALUE )
memory_stat_debug_mode = 1;
if( opt.debug & DBG_MPI_VALUE )
mpi_debug_mode = 1;
if( opt.debug & DBG_CIPHER_VALUE )
g10c_debug_mode = 1;
if( opt.debug & DBG_IOBUF_VALUE )
iobuf_debug_mode = 1;
}
static void
set_cmd( enum cmd_and_opt_values *ret_cmd, enum cmd_and_opt_values new_cmd )
{
enum cmd_and_opt_values cmd = *ret_cmd;
if( !cmd || cmd == new_cmd )
cmd = new_cmd;
else if( cmd == aSign && new_cmd == aEncr )
cmd = aSignEncr;
else if( cmd == aEncr && new_cmd == aSign )
cmd = aSignEncr;
else if( cmd == aKMode && new_cmd == aSym )
cmd = aKModeC;
else if( ( cmd == aSign && new_cmd == aClearsign )
|| ( cmd == aClearsign && new_cmd == aSign ) )
cmd = aClearsign;
else {
log_error(_("conflicting commands\n"));
g10_exit(2);
}
*ret_cmd = cmd;
}
int
main( int argc, char **argv )
{
ARGPARSE_ARGS pargs;
IOBUF a;
int rc=0;
int orig_argc;
char **orig_argv;
const char *fname;
STRLIST sl, remusr= NULL, locusr=NULL;
STRLIST nrings=NULL, sec_nrings=NULL;
armor_filter_context_t afx;
int detached_sig = 0;
FILE *configfp = NULL;
char *configname = NULL;
unsigned configlineno;
int parse_debug = 0;
int default_config =1;
int default_keyring = 1;
int greeting = 1;
enum cmd_and_opt_values cmd = 0;
const char *trustdb_name = NULL;
char *def_cipher_string = NULL;
char *def_digest_string = NULL;
char *s2k_cipher_string = NULL;
char *s2k_digest_string = NULL;
int pwfd = -1;
#ifdef USE_SHM_COPROCESSING
ulong requested_shm_size=0;
#endif
trap_unaligned();
secmem_set_flags( secmem_get_flags() | 2 ); /* suspend warnings */
#ifdef IS_G10MAINT
secmem_init( 0 ); /* disable use of secmem */
maybe_setuid = 0;
log_set_name("gpgm");
#else
/* Please note that we may running SUID(ROOT), so be very CAREFUL
* when adding any stuff between here and the call to
* secmem_init() somewhere after the option parsing
*/
log_set_name("gpg");
secure_random_alloc(); /* put random number into secure memory */
disable_core_dumps();
#endif
init_signals();
i18n_init();
opt.compress = -1; /* defaults to standard compress level */
/* fixme: set the next two to zero and decide where used */
opt.def_cipher_algo = 0;
opt.def_digest_algo = 0;
opt.def_compress_algo = 2;
opt.s2k_mode = 1; /* salted */
opt.s2k_digest_algo = DIGEST_ALGO_RMD160;
opt.s2k_cipher_algo = CIPHER_ALGO_BLOWFISH;
opt.completes_needed = 1;
opt.marginals_needed = 3;
opt.max_cert_depth = 5;
opt.homedir = getenv("GNUPGHOME");
if( !opt.homedir || !*opt.homedir ) {
#ifdef __MINGW32__
opt.homedir = "c:/gnupg";
#else
opt.homedir = "~/.gnupg";
#endif
}
/* check whether we have a config file on the commandline */
orig_argc = argc;
orig_argv = argv;
pargs.argc = &argc;
pargs.argv = &argv;
pargs.flags= 1|(1<<6); /* do not remove the args, ignore version */
while( arg_parse( &pargs, opts) ) {
if( pargs.r_opt == oDebug || pargs.r_opt == oDebugAll )
parse_debug++;
else if( pargs.r_opt == oOptions ) {
/* yes there is one, so we do not try the default one, but
* read the option file when it is encountered at the commandline
*/
default_config = 0;
}
else if( pargs.r_opt == oNoOptions )
default_config = 0; /* --no-options */
else if( pargs.r_opt == oHomedir )
opt.homedir = pargs.r.ret_str;
#ifdef USE_SHM_COPROCESSING
else if( pargs.r_opt == oRunAsShmCP ) {
/* does not make sense in a options file, we do it here,
* so that we are the able to drop setuid as soon as possible */
opt.shm_coprocess = 1;
requested_shm_size = pargs.r.ret_ulong;
}
#endif
}
#ifdef USE_SHM_COPROCESSING
if( opt.shm_coprocess ) {
#ifdef IS_G10
init_shm_coprocessing(requested_shm_size, 1 );
#else
init_shm_coprocessing(requested_shm_size, 0 );
#endif
}
#endif
#ifdef IS_G10
/* initialize the secure memory. */
secmem_init( 16384 );
maybe_setuid = 0;
/* Okay, we are now working under our real uid */
#endif
if( default_config )
configname = make_filename(opt.homedir, "options", NULL );
argc = orig_argc;
argv = orig_argv;
pargs.argc = &argc;
pargs.argv = &argv;
pargs.flags= 1; /* do not remove the args */
next_pass:
if( configname ) {
configlineno = 0;
configfp = fopen( configname, "r" );
if( !configfp ) {
if( default_config ) {
if( parse_debug )
log_info(_("NOTE: no default option file '%s'\n"),
configname );
}
else {
log_error(_("option file '%s': %s\n"),
configname, strerror(errno) );
g10_exit(2);
}
m_free(configname); configname = NULL;
}
if( parse_debug && configname )
log_info(_("reading options from '%s'\n"), configname );
default_config = 0;
}
while( optfile_parse( configfp, configname, &configlineno,
&pargs, opts) ) {
switch( pargs.r_opt ) {
case aCheckKeys: set_cmd( &cmd, aCheckKeys); break;
case aListPackets: set_cmd( &cmd, aListPackets); break;
case aImport: set_cmd( &cmd, aImport); break;
case aFastImport: set_cmd( &cmd, aFastImport); break;
case aExport: set_cmd( &cmd, aExport); break;
case aExportAll: set_cmd( &cmd, aExportAll); break;
case aListKeys: set_cmd( &cmd, aListKeys); break;
case aListSigs: set_cmd( &cmd, aListSigs); break;
case aExportSecret: set_cmd( &cmd, aExportSecret); break;
case aDeleteSecretKey: set_cmd( &cmd, aDeleteSecretKey); break;
case aDeleteKey: set_cmd( &cmd, aDeleteKey); break;
#ifdef IS_G10
case aDetachedSign: detached_sig = 1; set_cmd( &cmd, aSign ); break;
case aSym: set_cmd( &cmd, aSym); break;
case aDecrypt: set_cmd( &cmd, aDecrypt); break;
case aEncr: set_cmd( &cmd, aEncr); break;
case aSign: set_cmd( &cmd, aSign ); break;
case aKeygen: set_cmd( &cmd, aKeygen); break;
case aSignKey: set_cmd( &cmd, aSignKey); break;
case aStore: set_cmd( &cmd, aStore); break;
case aEditKey: set_cmd( &cmd, aEditKey); break;
case aClearsign: set_cmd( &cmd, aClearsign); break;
case aGenRevoke: set_cmd( &cmd, aGenRevoke); break;
case aVerify: set_cmd( &cmd, aVerify); break;
#else
#ifdef MAINTAINER_OPTIONS
case aPrimegen: set_cmd( &cmd, aPrimegen); break;
case aGenRandom: set_cmd( &cmd, aGenRandom); break;
#endif
case aPrintMD: set_cmd( &cmd, aPrintMD); break;
case aPrintMDs: set_cmd( &cmd, aPrintMDs); break;
case aListTrustDB: set_cmd( &cmd, aListTrustDB); break;
case aCheckTrustDB: set_cmd( &cmd, aCheckTrustDB); break;
case aUpdateTrustDB: set_cmd( &cmd, aUpdateTrustDB); break;
case aFixTrustDB: set_cmd( &cmd, aFixTrustDB); break;
case aListTrustPath: set_cmd( &cmd, aListTrustPath); break;
case aDeArmor: set_cmd( &cmd, aDeArmor); break;
case aEnArmor: set_cmd( &cmd, aEnArmor); break;
case aExportOwnerTrust: set_cmd( &cmd, aExportOwnerTrust); break;
case aImportOwnerTrust: set_cmd( &cmd, aImportOwnerTrust); break;
#endif /* IS_G10MAINT */
case oArmor: opt.armor = 1; opt.no_armor=0; break;
case oOutput: opt.outfile = pargs.r.ret_str; break;
case oQuiet: opt.quiet = 1; break;
case oVerbose: g10_opt_verbose++;
opt.verbose++; opt.list_sigs=1; break;
case oKOption: set_cmd( &cmd, aKMode ); break;
case oBatch: opt.batch = 1; greeting = 0; break;
case oAnswerYes: opt.answer_yes = 1; break;
case oAnswerNo: opt.answer_no = 1; break;
case oKeyring: append_to_strlist( &nrings, pargs.r.ret_str); break;
case oDebug: opt.debug |= pargs.r.ret_ulong; break;
case oDebugAll: opt.debug = ~0; break;
case oStatusFD: set_status_fd( pargs.r.ret_int ); break;
case oFingerprint: opt.fingerprint++; break;
case oSecretKeyring: append_to_strlist( &sec_nrings, pargs.r.ret_str); break;
case oOptions:
/* config files may not be nested (silently ignore them) */
if( !configfp ) {
m_free(configname);
configname = m_strdup(pargs.r.ret_str);
goto next_pass;
}
break;
case oNoArmor: opt.no_armor=1; opt.armor=0; break;
case oNoDefKeyring: default_keyring = 0; break;
case oNoGreeting: greeting = 0; break;
case oNoVerbose: g10_opt_verbose = 0;
opt.verbose = 0; opt.list_sigs=0; break;
case oQuickRandom: quick_random_gen(1); break;
case oNoComment: opt.no_comment=1; break;
case oCompletesNeeded: opt.completes_needed = pargs.r.ret_int; break;
case oMarginalsNeeded: opt.marginals_needed = pargs.r.ret_int; break;
case oMaxCertDepth: opt.max_cert_depth = pargs.r.ret_int; break;
case oTrustDBName: trustdb_name = pargs.r.ret_str; break;
case oDefaultKey: opt.def_secret_key = pargs.r.ret_str; break;
case oTrustedKey: register_trusted_key( pargs.r.ret_str ); break;
case oNoOptions: break; /* no-options */
case oHomedir: opt.homedir = pargs.r.ret_str; break;
case oNoBatch: opt.batch = 0; break;
case oWithColons: opt.with_colons=':'; break;
case oSkipVerify: opt.skip_verify=1; break;
case oCompressAlgo: opt.def_compress_algo = pargs.r.ret_int; break;
case oCompressKeys: opt.compress_keys = 1; break;
case aListSecretKeys: set_cmd( &cmd, aListSecretKeys); break;
case oAlwaysTrust: opt.always_trust = 1; break;
case oLoadExtension:
register_cipher_extension(orig_argc? *orig_argv:NULL,
pargs.r.ret_str);
break;
- case oRFC1991: opt.rfc1991 = 1; opt.no_comment = 1; break;
+ case oRFC1991:
+ opt.rfc1991 = 1;
+ opt.no_comment = 1;
+ opt.escape_from = 1;
+ break;
case oEmuChecksumBug: opt.emulate_bugs |= EMUBUG_GPGCHKSUM; break;
case oCompressSigs: opt.compress_sigs = 1; break;
case oRunAsShmCP:
#ifndef USE_SHM_COPROCESSING
/* not possible in the option file,
* but we print the warning here anyway */
log_error("shared memory coprocessing is not available\n");
#endif
break;
case oSetFilename: opt.set_filename = pargs.r.ret_str; break;
case oComment: opt.comment_string = pargs.r.ret_str; break;
case oThrowKeyid: opt.throw_keyid = 1; break;
case oForceV3Sigs: opt.force_v3_sigs = 1; break;
case oS2KMode: opt.s2k_mode = pargs.r.ret_int; break;
case oS2KDigest: s2k_digest_string = m_strdup(pargs.r.ret_str); break;
case oS2KCipher: s2k_cipher_string = m_strdup(pargs.r.ret_str); break;
#ifdef IS_G10
case oRemote: /* store the remote users */
sl = m_alloc( sizeof *sl + strlen(pargs.r.ret_str));
strcpy(sl->d, pargs.r.ret_str);
sl->next = remusr;
remusr = sl;
break;
case oTextmodeShort: opt.textmode = 2; break;
case oTextmode: opt.textmode=1; break;
case oUser: /* store the local users */
sl = m_alloc( sizeof *sl + strlen(pargs.r.ret_str));
strcpy(sl->d, pargs.r.ret_str);
sl->next = locusr;
locusr = sl;
break;
case oCompress: opt.compress = pargs.r.ret_int; break;
case oPasswdFD: pwfd = pargs.r.ret_int; break;
case oCipherAlgo: def_cipher_string = m_strdup(pargs.r.ret_str); break;
case oDigestAlgo: def_digest_string = m_strdup(pargs.r.ret_str); break;
case oNoSecmemWarn: secmem_set_flags( secmem_get_flags() | 1 ); break;
#else
case oCipherAlgo:
case oDigestAlgo:
case oNoSecmemWarn:
break; /* dummies */
#endif
case oCharset:
if( set_native_charset( pargs.r.ret_str ) )
log_error(_("%s is not a valid character set\n"),
pargs.r.ret_str);
break;
case oNotDashEscaped: opt.not_dash_escaped = 1; break;
+ case oEscapeFrom: opt.escape_from = 1; break;
case oLockOnce: opt.lock_once = 1; break;
default : pargs.err = configfp? 1:2; break;
}
}
if( configfp ) {
fclose( configfp );
configfp = NULL;
m_free(configname); configname = NULL;
goto next_pass;
}
m_free( configname ); configname = NULL;
if( log_get_errorcount(0) )
g10_exit(2);
if( greeting ) {
tty_printf("%s %s; %s\n", strusage(11), strusage(13), strusage(14) );
tty_printf("%s\n", strusage(15) );
}
secmem_set_flags( secmem_get_flags() & ~2 ); /* resume warnings */
set_debug();
/* must do this after dropping setuid, because string_to...
* may try to load an module */
if( def_cipher_string ) {
opt.def_cipher_algo = string_to_cipher_algo(def_cipher_string);
m_free(def_cipher_string); def_cipher_string = NULL;
if( check_cipher_algo(opt.def_cipher_algo) )
log_error(_("selected cipher algorithm is invalid\n"));
}
if( def_digest_string ) {
opt.def_digest_algo = string_to_digest_algo(def_digest_string);
m_free(def_digest_string); def_digest_string = NULL;
if( check_digest_algo(opt.def_digest_algo) )
log_error(_("selected digest algorithm is invalid\n"));
}
if( s2k_cipher_string ) {
opt.s2k_cipher_algo = string_to_cipher_algo(s2k_cipher_string);
m_free(s2k_cipher_string); s2k_cipher_string = NULL;
if( check_cipher_algo(opt.s2k_cipher_algo) )
log_error(_("selected cipher algorithm is invalid\n"));
}
if( s2k_digest_string ) {
opt.s2k_digest_algo = string_to_digest_algo(s2k_digest_string);
m_free(s2k_digest_string); s2k_digest_string = NULL;
if( check_digest_algo(opt.s2k_digest_algo) )
log_error(_("selected digest algorithm is invalid\n"));
}
if( opt.def_compress_algo < 1 || opt.def_compress_algo > 2 )
log_error(_("compress algorithm must be in range %d..%d\n"), 1, 2);
if( opt.completes_needed < 1 )
log_error(_("completes-needed must be greater than 0\n"));
if( opt.marginals_needed < 2 )
log_error(_("marginals-needed must be greater than 1\n"));
if( opt.max_cert_depth < 1 || opt.max_cert_depth > 255 )
log_error(_("max-cert-depth must be in range 1 to 255\n"));
switch( opt.s2k_mode ) {
case 0:
log_info(_("NOTE: simple S2K mode (0) is strongly discouraged\n"));
break;
case 1: case 3: break;
default:
log_error(_("invalid S2K mode; must be 0, 1 or 3\n"));
}
{ const char *p = strusage(13);
for( ; *p && (isdigit(*p) || *p=='.'); p++ )
;
if( *p )
log_info("NOTE: This is a development version!\n");
}
if( log_get_errorcount(0) )
g10_exit(2);
if( !cmd && opt.fingerprint )
set_cmd( &cmd, aListKeys);
if( cmd == aKMode || cmd == aKModeC ) { /* kludge to be compatible to pgp */
if( cmd == aKModeC ) {
opt.fingerprint = 1;
cmd = aKMode;
}
opt.list_sigs = 0;
if( opt.verbose > 2 )
opt.check_sigs++;
if( opt.verbose > 1 )
opt.list_sigs++;
opt.verbose = opt.verbose > 1;
g10_opt_verbose = opt.verbose;
}
/* kludge to let -sat generate a clear text signature */
if( opt.textmode == 2 && !detached_sig && opt.armor && cmd == aSign )
cmd = aClearsign;
if( opt.verbose > 1 )
set_packet_list_mode(1);
/* add the keyrings, but not for some special commands and
* not in case of "-kvv userid keyring" */
if( cmd != aDeArmor && cmd != aEnArmor
&& !(cmd == aKMode && argc == 2 ) ) {
if( !sec_nrings || default_keyring ) /* add default secret rings */
add_keyblock_resource("secring.gpg", 0, 1);
for(sl = sec_nrings; sl; sl = sl->next )
add_keyblock_resource( sl->d, 0, 1 );
if( !nrings || default_keyring ) /* add default ring */
add_keyblock_resource("pubring.gpg", 0, 0);
for(sl = nrings; sl; sl = sl->next )
add_keyblock_resource( sl->d, 0, 0 );
}
FREE_STRLIST(nrings);
FREE_STRLIST(sec_nrings);
if( pwfd != -1 ) /* read the passphrase now. */
read_passphrase_from_fd( pwfd );
fname = argc? *argv : NULL;
switch( cmd ) {
case aPrimegen:
case aPrintMD:
case aPrintMDs:
case aGenRandom:
case aDeArmor:
case aEnArmor:
case aFixTrustDB:
break;
case aKMode:
case aListKeys:
case aListSecretKeys:
case aCheckKeys:
if( opt.with_colons ) /* need this to list the trust */
rc = init_trustdb(1, trustdb_name );
break;
case aExportOwnerTrust: rc = init_trustdb( 0, trustdb_name ); break;
case aListTrustDB: rc = init_trustdb( argc? 1:0, trustdb_name ); break;
default: rc = init_trustdb(1, trustdb_name ); break;
}
if( rc )
log_error(_("failed to initialize the TrustDB: %s\n"), g10_errstr(rc));
switch( cmd ) {
case aStore: /* only store the file */
if( argc > 1 )
wrong_args(_("--store [filename]"));
if( (rc = encode_store(fname)) )
log_error_f( print_fname_stdin(fname),
"store failed: %s\n", g10_errstr(rc) );
break;
#ifdef IS_G10
case aSym: /* encrypt the given file only with the symmetric cipher */
if( argc > 1 )
wrong_args(_("--symmetric [filename]"));
if( (rc = encode_symmetric(fname)) )
log_error_f(print_fname_stdin(fname),
"symmetric encryption failed: %s\n",g10_errstr(rc) );
break;
case aEncr: /* encrypt the given file */
if( argc > 1 )
wrong_args(_("--encrypt [filename]"));
if( (rc = encode_crypt(fname,remusr)) )
log_error("%s: encryption failed: %s\n", print_fname_stdin(fname), g10_errstr(rc) );
break;
case aSign: /* sign the given file */
sl = NULL;
if( detached_sig ) { /* sign all files */
for( ; argc; argc--, argv++ )
add_to_strlist( &sl, *argv );
}
else {
if( argc > 1 )
wrong_args(_("--sign [filename]"));
if( argc ) {
sl = m_alloc_clear( sizeof *sl + strlen(fname));
strcpy(sl->d, fname);
}
}
if( (rc = sign_file( sl, detached_sig, locusr, 0, NULL, NULL)) )
log_error("signing failed: %s\n", g10_errstr(rc) );
free_strlist(sl);
break;
case aSignEncr: /* sign and encrypt the given file */
if( argc > 1 )
wrong_args(_("--sign --encrypt [filename]"));
if( argc ) {
sl = m_alloc_clear( sizeof *sl + strlen(fname));
strcpy(sl->d, fname);
}
else
sl = NULL;
if( (rc = sign_file(sl, detached_sig, locusr, 1, remusr, NULL)) )
log_error("%s: sign+encrypt failed: %s\n", print_fname_stdin(fname), g10_errstr(rc) );
free_strlist(sl);
break;
case aClearsign: /* make a clearsig */
if( argc > 1 )
wrong_args(_("--clearsign [filename]"));
if( (rc = clearsign_file(fname, locusr, NULL)) )
log_error("%s: clearsign failed: %s\n", print_fname_stdin(fname), g10_errstr(rc) );
break;
case aVerify:
if( (rc = verify_signatures( argc, argv ) ))
log_error("verify signatures failed: %s\n", g10_errstr(rc) );
break;
case aDecrypt:
if( argc > 1 )
wrong_args(_("--decrypt [filename]"));
if( (rc = decrypt_message( fname ) ))
log_error("decrypt_message failed: %s\n", g10_errstr(rc) );
break;
case aSignKey: /* sign the key given as argument */
case aEditKey: /* Edit a key signature */
if( !argc )
wrong_args(_("--edit-key username [commands]"));
if( argc > 1 ) {
sl = NULL;
for( argc--, argv++ ; argc; argc--, argv++ )
append_to_strlist( &sl, *argv );
keyedit_menu( fname, locusr, sl );
free_strlist(sl);
}
else
keyedit_menu(fname, locusr, NULL );
break;
#endif /* IS_G10 */
case aDeleteSecretKey:
if( argc != 1 )
wrong_args(_("--delete-secret-key username"));
case aDeleteKey:
if( argc != 1 )
wrong_args(_("--delete-key username"));
/* note: fname is the user id! */
if( (rc = delete_key(fname, cmd==aDeleteSecretKey)) )
log_error("%s: delete key failed: %s\n", print_fname_stdin(fname), g10_errstr(rc) );
break;
case aCheckKeys:
opt.check_sigs = 1;
case aListSigs:
opt.list_sigs = 1;
case aListKeys:
public_key_list( argc, argv );
break;
case aListSecretKeys:
secret_key_list( argc, argv );
break;
case aKMode: /* list keyring */
if( argc < 2 ) /* -kv [userid] */
public_key_list( (argc && **argv)? 1:0, argv );
else if( argc == 2 ) { /* -kv userid keyring */
if( access( argv[1], R_OK ) ) {
log_error(_("can't open %s: %s\n"),
print_fname_stdin(argv[1]), strerror(errno));
}
else {
/* add keyring (default keyrings are not registered in this
* special case */
add_keyblock_resource( argv[1], 0, 0 );
public_key_list( **argv?1:0, argv );
}
}
else
wrong_args(_("-k[v][v][v][c] [userid] [keyring]") );
break;
#ifdef IS_G10
case aKeygen: /* generate a key (interactive) */
if( argc )
wrong_args("--gen-key");
generate_keypair();
break;
#endif
case aFastImport:
case aImport:
if( !argc ) {
rc = import_keys( NULL, (cmd == aFastImport) );
if( rc )
log_error("import failed: %s\n", g10_errstr(rc) );
}
for( ; argc; argc--, argv++ ) {
rc = import_keys( *argv, (cmd == aFastImport) );
if( rc )
log_error("import from '%s' failed: %s\n",
*argv, g10_errstr(rc) );
}
break;
case aExport:
case aExportAll:
sl = NULL;
for( ; argc; argc--, argv++ )
add_to_strlist( &sl, *argv );
export_pubkeys( sl, (cmd == aExport) );
free_strlist(sl);
break;
case aExportSecret:
sl = NULL;
for( ; argc; argc--, argv++ )
add_to_strlist( &sl, *argv );
export_seckeys( sl );
free_strlist(sl);
break;
#ifdef IS_G10
case aGenRevoke:
if( argc != 1 )
wrong_args("--gen-revoke user-id");
gen_revoke( *argv );
break;
#endif
#ifdef IS_G10MAINT
case aDeArmor:
if( argc > 1 )
wrong_args("--dearmor [file]");
rc = dearmor_file( argc? *argv: NULL );
if( rc )
log_error(_("dearmoring failed: %s\n"), g10_errstr(rc));
break;
case aEnArmor:
if( argc > 1 )
wrong_args("--enarmor [file]");
rc = enarmor_file( argc? *argv: NULL );
if( rc )
log_error(_("enarmoring failed: %s\n"), g10_errstr(rc));
break;
#ifdef MAINTAINER_OPTIONS
case aPrimegen:
if( argc == 1 ) {
mpi_print( stdout, generate_public_prime( atoi(argv[0]) ), 1);
putchar('\n');
}
else if( argc == 2 ) {
mpi_print( stdout, generate_elg_prime( 0, atoi(argv[0]),
atoi(argv[1]), NULL,NULL ), 1);
putchar('\n');
}
else if( argc == 3 ) {
MPI g = mpi_alloc(1);
mpi_print( stdout, generate_elg_prime( 0, atoi(argv[0]),
atoi(argv[1]), g, NULL ), 1);
printf("\nGenerator: ");
mpi_print( stdout, g, 1 );
putchar('\n');
mpi_free(g);
}
else if( argc == 4 ) {
mpi_print( stdout, generate_elg_prime( 1, atoi(argv[0]),
atoi(argv[1]), NULL,NULL ), 1);
putchar('\n');
}
else
usage(1);
break;
#endif /* MAINTAINER OPTIONS */
#ifdef MAINTAINER_OPTIONS
case aGenRandom:
if( argc < 1 || argc > 2 )
wrong_args("--gen-random level [hex]");
{
int c;
int level = atoi(*argv);
for(;;) {
byte *p;
if( argc == 2 ) {
p = get_random_bits( 8, level, 0);
printf("%02x", *p );
fflush(stdout);
}
else {
p = get_random_bits( 800, level, 0);
for(c=0; c < 100; c++ )
putchar( p[c] );
}
m_free(p);
}
}
break;
#endif /* MAINTAINER OPTIONS */
case aPrintMD:
if( argc < 1)
wrong_args("--print-md algo [file]");
else {
int algo = string_to_digest_algo(*argv);
if( !algo )
log_error(_("invalid hash algorithm '%s'\n"), *argv );
else {
argc--; argv++;
if( !argc )
print_mds(NULL, algo);
else {
for(; argc; argc--, argv++ )
print_mds(*argv, algo);
}
}
}
break;
case aPrintMDs:
if( !argc )
print_mds(NULL,0);
else {
for(; argc; argc--, argv++ )
print_mds(*argv,0);
}
break;
case aListTrustDB:
if( !argc )
list_trustdb(NULL);
else {
for( ; argc; argc--, argv++ )
list_trustdb( *argv );
}
break;
case aUpdateTrustDB:
if( argc )
wrong_args("--update-trustdb");
update_trustdb();
break;
case aCheckTrustDB:
if( !argc )
check_trustdb(NULL);
else {
for( ; argc; argc--, argv++ )
check_trustdb( *argv );
}
break;
case aFixTrustDB:
log_error("this command ist not yet implemented.\"\n");
log_error("A workaround is to use \"--export-ownertrust\", remove\n");
log_error("the trustdb file and do an \"--import-ownertrust\".\n" );
break;
case aListTrustPath:
if( !argc )
wrong_args("--list-trust-path <usernames>");
for( ; argc; argc--, argv++ )
list_trust_path( *argv );
break;
case aExportOwnerTrust:
if( argc )
wrong_args("--export-ownertrust");
export_ownertrust();
break;
case aImportOwnerTrust:
if( argc > 1 )
wrong_args("--import-ownertrust [file]");
import_ownertrust( argc? *argv:NULL );
break;
#endif /* IS_G10MAINT */
case aListPackets:
opt.list_packets=1;
default:
/* fixme: g10maint should do regular maintenace tasks here */
if( argc > 1 )
wrong_args(_("[filename]"));
/* Issue some output for the unix newbie */
if( !fname && !opt.outfile && isatty( fileno(stdin) )
&& isatty( fileno(stdout) ) && isatty( fileno(stderr) ) )
log_info(_("Go ahead and type your message ...\n"));
if( !(a = iobuf_open(fname)) )
log_error(_("can't open '%s'\n"), print_fname_stdin(fname));
else {
if( !opt.no_armor ) {
if( use_armor_filter( a ) ) {
memset( &afx, 0, sizeof afx);
iobuf_push_filter( a, armor_filter, &afx );
}
}
if( cmd == aListPackets ) {
set_packet_list_mode(1);
opt.list_packets=1;
}
proc_packets( a );
iobuf_close(a);
}
break;
}
/* cleanup */
FREE_STRLIST(remusr);
FREE_STRLIST(locusr);
g10_exit(0);
return 8; /*NEVER REACHED*/
}
void
g10_exit( int rc )
{
if( opt.debug & DBG_MEMSTAT_VALUE )
m_print_stats("on exit");
if( opt.debug )
secmem_dump_stats();
secmem_term();
rc = rc? rc : log_get_errorcount(0)? 2 :
g10_errors_seen? 1 : 0;
/*write_status( STATUS_LEAVE );*/
exit(rc );
}
#ifdef IS_G10MAINT
static void
print_hex( byte *p, size_t n )
{
int i;
if( n == 20 ) {
for(i=0; i < n ; i++, i++, p += 2 ) {
if( i )
putchar(' ');
if( i == 10 )
putchar(' ');
printf("%02X%02X", *p, p[1] );
}
}
else if( n == 24 ) {
for(i=0; i < n ; i += 4, p += 4 ) {
if( i )
putchar(' ');
if( i == 12 )
putchar(' ');
printf("%02X%02X%02X%02X", *p, p[1], p[2], p[3] );
}
}
else {
for(i=0; i < n ; i++, p++ ) {
if( i )
putchar(' ');
if( i && !(i%8) )
putchar(' ');
printf("%02X", *p );
}
}
}
static void
print_mds( const char *fname, int algo )
{
FILE *fp;
char buf[1024];
size_t n;
MD_HANDLE md;
char *pname;
if( !fname ) {
fp = stdin;
pname = m_strdup("[stdin]: ");
}
else {
pname = m_alloc(strlen(fname)+3);
strcpy(stpcpy(pname,fname),": ");
fp = fopen( fname, "rb" );
}
if( !fp ) {
log_error("%s%s\n", pname, strerror(errno) );
m_free(pname);
return;
}
md = md_open( 0, 0 );
if( algo )
md_enable( md, algo );
else {
md_enable( md, DIGEST_ALGO_MD5 );
md_enable( md, DIGEST_ALGO_SHA1 );
md_enable( md, DIGEST_ALGO_RMD160 );
if( !check_digest_algo(DIGEST_ALGO_TIGER) )
md_enable( md, DIGEST_ALGO_TIGER );
}
while( (n=fread( buf, 1, DIM(buf), fp )) )
md_write( md, buf, n );
if( ferror(fp) )
log_error("%s%s\n", pname, strerror(errno) );
else {
md_final(md);
if( algo ) {
if( fname )
fputs( pname, stdout );
print_hex(md_read(md, algo), md_digest_length(algo) );
}
else {
printf( "%s MD5 = ", fname?pname:"" );
print_hex(md_read(md, DIGEST_ALGO_MD5), 16 );
printf("\n%s SHA1 = ", fname?pname:"" );
print_hex(md_read(md, DIGEST_ALGO_SHA1), 20 );
printf("\n%sRMD160 = ", fname?pname:"" );
print_hex(md_read(md, DIGEST_ALGO_RMD160), 20 );
if( !check_digest_algo(DIGEST_ALGO_TIGER) ) {
printf("\n%s TIGER = ", fname?pname:"" );
print_hex(md_read(md, DIGEST_ALGO_TIGER), 24 );
}
}
putchar('\n');
}
md_close(md);
if( fp != stdin )
fclose(fp);
}
#endif /* IS_G10MAINT */
diff --git a/g10/mainproc.c b/g10/mainproc.c
index 02d42223b..acf5bf5e7 100644
--- a/g10/mainproc.c
+++ b/g10/mainproc.c
@@ -1,944 +1,944 @@
/* mainproc.c - handle packets
* Copyright (C) 1998 Free Software Foundation, Inc.
*
* This file is part of GNUPG.
*
* GNUPG 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.
*
* GNUPG 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 <time.h>
#include "packet.h"
#include "iobuf.h"
#include "memory.h"
#include "options.h"
#include "util.h"
#include "cipher.h"
#include "keydb.h"
#include "filter.h"
#include "cipher.h"
#include "main.h"
#include "status.h"
#include "i18n.h"
#include "trustdb.h"
/****************
* Structure to hold the context
*/
typedef struct {
PKT_public_key *last_pubkey;
PKT_secret_key *last_seckey;
PKT_user_id *last_user_id;
md_filter_context_t mfx;
int sigs_only; /* process only signatures and reject all other stuff */
int encrypt_only; /* process only encrytion messages */
STRLIST signed_data;
const char *sigfilename;
DEK *dek;
int last_was_session_key;
KBNODE list; /* the current list of packets */
int have_data;
IOBUF iobuf; /* used to get the filename etc. */
int trustletter; /* temp usage in list_node */
ulong local_id; /* ditto */
} *CTX;
static int do_proc_packets( CTX c, IOBUF a );
static void list_node( CTX c, KBNODE node );
static void proc_tree( CTX c, KBNODE node );
static void
release_list( CTX c )
{
if( !c->list )
return;
proc_tree(c, c->list );
release_kbnode( c->list );
c->list = NULL;
}
static int
add_onepass_sig( CTX c, PACKET *pkt )
{
KBNODE node;
if( c->list ) { /* add another packet */
if( c->list->pkt->pkttype != PKT_ONEPASS_SIG ) {
log_error("add_onepass_sig: another packet is in the way\n");
release_list( c );
c->list = new_kbnode( pkt );
}
else
add_kbnode( c->list, new_kbnode( pkt ));
}
else /* insert the first one */
c->list = node = new_kbnode( pkt );
return 1;
}
static int
add_user_id( CTX c, PACKET *pkt )
{
if( !c->list ) {
log_error("orphaned user id\n" );
return 0;
}
add_kbnode( c->list, new_kbnode( pkt ) );
return 1;
}
static int
add_subkey( CTX c, PACKET *pkt )
{
if( !c->list ) {
log_error("subkey w/o mainkey\n" );
return 0;
}
add_kbnode( c->list, new_kbnode( pkt ) );
return 1;
}
static int
add_signature( CTX c, PACKET *pkt )
{
KBNODE node;
if( pkt->pkttype == PKT_SIGNATURE && !c->list ) {
/* This is the first signature for the following datafile.
* G10 does not write such packets; instead it always uses
* onepass-sig packets. The drawback of PGP's method
* of prepending the signature to the data is
* that it is not possible to make a signature from data read
* from stdin. (G10 is able to read PGP stuff anyway.) */
node = new_kbnode( pkt );
c->list = node;
return 1;
}
else if( !c->list )
return 0; /* oops (invalid packet sequence)*/
else if( !c->list->pkt )
BUG(); /* so nicht */
/* add a new signature node id at the end */
node = new_kbnode( pkt );
add_kbnode( c->list, node );
return 1;
}
static void
proc_symkey_enc( CTX c, PACKET *pkt )
{
PKT_symkey_enc *enc;
enc = pkt->pkt.symkey_enc;
if( enc->seskeylen )
log_error( "symkey_enc packet with session keys are not supported!\n");
else {
c->last_was_session_key = 2;
c->dek = passphrase_to_dek( NULL, enc->cipher_algo, &enc->s2k, 0 );
}
free_packet(pkt);
}
static void
proc_pubkey_enc( CTX c, PACKET *pkt )
{
PKT_pubkey_enc *enc;
int result = 0;
/* check whether the secret key is available and store in this case */
c->last_was_session_key = 1;
enc = pkt->pkt.pubkey_enc;
/*printf("enc: encrypted by a pubkey with keyid %08lX\n", enc->keyid[1] );*/
if( is_ELGAMAL(enc->pubkey_algo)
|| enc->pubkey_algo == PUBKEY_ALGO_DSA
|| is_RSA(enc->pubkey_algo) ) {
if ( !c->dek ) {
c->dek = m_alloc_secure( sizeof *c->dek );
if( (result = get_session_key( enc, c->dek )) ) {
/* error: delete the DEK */
m_free(c->dek); c->dek = NULL;
}
}
}
else
result = G10ERR_PUBKEY_ALGO;
if( result == -1 )
;
else if( !result ) {
if( opt.verbose > 1 )
log_info( _("public key encrypted data: Good DEK\n") );
}
else {
log_error(_("public key decryption failed: %s\n"), g10_errstr(result));
}
free_packet(pkt);
}
static void
proc_encrypted( CTX c, PACKET *pkt )
{
int result = 0;
/*printf("dat: %sencrypted data\n", c->dek?"":"conventional ");*/
if( !c->dek && !c->last_was_session_key ) {
/* assume this is old conventional encrypted data */
c->dek = passphrase_to_dek( NULL,
opt.def_cipher_algo ? opt.def_cipher_algo
: DEFAULT_CIPHER_ALGO, NULL, 0 );
}
else if( !c->dek )
result = G10ERR_NO_SECKEY;
if( !result )
result = decrypt_data( pkt->pkt.encrypted, c->dek );
m_free(c->dek); c->dek = NULL;
if( result == -1 )
;
else if( !result ) {
if( opt.verbose > 1 )
log_info(_("decryption okay\n"));
}
else {
log_error(_("decryption failed: %s\n"), g10_errstr(result));
/* FIXME: if this is secret key not available, try with
* other keys */
}
free_packet(pkt);
c->last_was_session_key = 0;
}
static void
proc_plaintext( CTX c, PACKET *pkt )
{
PKT_plaintext *pt = pkt->pkt.plaintext;
int any, clearsig, rc;
KBNODE n;
if( pt->namelen == 8 && !memcmp( pt->name, "_CONSOLE", 8 ) )
log_info(_("NOTE: sender requested \"for-your-eyes-only\"\n"));
else if( opt.verbose )
log_info(_("original file name='%.*s'\n"), pt->namelen, pt->name);
free_md_filter_context( &c->mfx );
c->mfx.md = md_open( 0, 0);
/* fixme: we may need to push the textfilter if we have sigclass 1
* and no armoring - Not yet tested */
any = clearsig = 0;
for(n=c->list; n; n = n->next ) {
if( n->pkt->pkttype == PKT_ONEPASS_SIG ) {
if( n->pkt->pkt.onepass_sig->digest_algo ) {
md_enable( c->mfx.md, n->pkt->pkt.onepass_sig->digest_algo );
any = 1;
}
/* Check whether this is a cleartext signature. We assume that
* we have one if the sig_class is 1 and the keyid is 0, that
* are the faked packets produced by armor.c. There is a
* possibility that this fails, but there is no other easy way
* to do it. (We could use a special packet type to indicate
* this, but this may also be faked - it simply can't be verified
* and is _no_ security issue)
*/
if( n->pkt->pkt.onepass_sig->sig_class == 0x01
&& !n->pkt->pkt.onepass_sig->keyid[0]
&& !n->pkt->pkt.onepass_sig->keyid[1] )
clearsig = 1;
}
}
if( !any ) { /* no onepass sig packet: enable all standard algos */
md_enable( c->mfx.md, DIGEST_ALGO_RMD160 );
md_enable( c->mfx.md, DIGEST_ALGO_SHA1 );
md_enable( c->mfx.md, DIGEST_ALGO_MD5 );
}
- /*md_start_debug( c->mfx.md, "verify" );*/
+ md_start_debug( c->mfx.md, "verify" );
rc = handle_plaintext( pt, &c->mfx, c->sigs_only, clearsig );
if( rc == G10ERR_CREATE_FILE && !c->sigs_only) {
/* can't write output but we hash it anyway to
* check the signature */
rc = handle_plaintext( pt, &c->mfx, 1, clearsig );
}
if( rc )
log_error( "handle plaintext failed: %s\n", g10_errstr(rc));
free_packet(pkt);
c->last_was_session_key = 0;
}
static int
proc_compressed_cb( IOBUF a, void *info )
{
return proc_signature_packets( a, ((CTX)info)->signed_data,
((CTX)info)->sigfilename );
}
static int
proc_encrypt_cb( IOBUF a, void *info )
{
return proc_encryption_packets( a );
}
static void
proc_compressed( CTX c, PACKET *pkt )
{
PKT_compressed *zd = pkt->pkt.compressed;
int rc;
/*printf("zip: compressed data packet\n");*/
if( c->sigs_only )
rc = handle_compressed( zd, proc_compressed_cb, c );
else if( c->encrypt_only )
rc = handle_compressed( zd, proc_encrypt_cb, c );
else
rc = handle_compressed( zd, NULL, NULL );
if( rc )
log_error("uncompressing failed: %s\n", g10_errstr(rc));
free_packet(pkt);
c->last_was_session_key = 0;
}
/****************
* check the signature
* Returns: 0 = valid signature or an error code
*/
static int
do_check_sig( CTX c, KBNODE node, int *is_selfsig )
{
PKT_signature *sig;
MD_HANDLE md;
int algo, rc;
assert( node->pkt->pkttype == PKT_SIGNATURE );
if( is_selfsig )
*is_selfsig = 0;
sig = node->pkt->pkt.signature;
algo = sig->digest_algo;
if( !algo )
return G10ERR_PUBKEY_ALGO;
if( (rc=check_digest_algo(algo)) )
return rc;
if( c->mfx.md ) {
m_check(c->mfx.md);
if( c->mfx.md->list )
m_check( c->mfx.md->list );
}
if( sig->sig_class == 0x00 ) {
if( c->mfx.md )
md = md_copy( c->mfx.md );
else /* detached signature */
md = md_open( 0, 0 ); /* signature_check() will enable the md*/
}
else if( sig->sig_class == 0x01 ) {
/* how do we know that we have to hash the (already hashed) text
* in canonical mode ??? (calculating both modes???) */
if( c->mfx.md )
md = md_copy( c->mfx.md );
else /* detached signature */
md = md_open( 0, 0 ); /* signature_check() will enable the md*/
}
else if( (sig->sig_class&~3) == 0x10
|| sig->sig_class == 0x18
|| sig->sig_class == 0x20
|| sig->sig_class == 0x30 ) { /* classes 0x10..0x17,0x20,0x30 */
if( c->list->pkt->pkttype == PKT_PUBLIC_KEY
|| c->list->pkt->pkttype == PKT_PUBLIC_SUBKEY ) {
return check_key_signature( c->list, node, is_selfsig );
}
else {
log_error("invalid root packet for sigclass %02x\n",
sig->sig_class);
return G10ERR_SIG_CLASS;
}
}
else
return G10ERR_SIG_CLASS;
rc = signature_check( sig, md );
md_close(md);
return rc;
}
static void
print_userid( PACKET *pkt )
{
if( !pkt )
BUG();
if( pkt->pkttype != PKT_USER_ID ) {
printf("ERROR: unexpected packet type %d", pkt->pkttype );
return;
}
print_string( stdout, pkt->pkt.user_id->name, pkt->pkt.user_id->len,
opt.with_colons );
}
static void
print_fingerprint( PKT_public_key *pk, PKT_secret_key *sk )
{
byte array[MAX_FINGERPRINT_LEN], *p;
size_t i, n;
if( sk )
fingerprint_from_sk( sk, array, &n );
else
fingerprint_from_pk( pk, array, &n );
p = array;
if( opt.with_colons ) {
printf("fpr:::::::::");
for(i=0; i < n ; i++, p++ )
printf("%02X", *p );
putchar(':');
}
else {
printf(" Key fingerprint =");
if( n == 20 ) {
for(i=0; i < n ; i++, i++, p += 2 ) {
if( i == 10 )
putchar(' ');
printf(" %02X%02X", *p, p[1] );
}
}
else {
for(i=0; i < n ; i++, p++ ) {
if( i && !(i%8) )
putchar(' ');
printf(" %02X", *p );
}
}
}
putchar('\n');
}
/****************
* List the certificate in a user friendly way
*/
static void
list_node( CTX c, KBNODE node )
{
int any=0;
int mainkey;
if( !node )
;
else if( (mainkey = (node->pkt->pkttype == PKT_PUBLIC_KEY) )
|| node->pkt->pkttype == PKT_PUBLIC_SUBKEY ) {
PKT_public_key *pk = node->pkt->pkt.public_key;
if( opt.with_colons ) {
u32 keyid[2];
keyid_from_pk( pk, keyid );
if( mainkey ) {
c->local_id = pk->local_id;
c->trustletter = query_trust_info( pk );
}
printf("%s:%c:%u:%d:%08lX%08lX:%s:%s:",
mainkey? "pub":"sub",
c->trustletter,
nbits_from_pk( pk ),
pk->pubkey_algo,
(ulong)keyid[0],(ulong)keyid[1],
datestr_from_pk( pk ),
pk->expiredate? strtimestamp(pk->expiredate):"" );
if( c->local_id )
printf("%lu", c->local_id );
putchar(':');
if( c->local_id )
putchar( get_ownertrust_info( c->local_id ) );
putchar(':');
}
else
printf("%s %4u%c/%08lX %s ",
mainkey? "pub":"sub",
nbits_from_pk( pk ),
pubkey_letter( pk->pubkey_algo ),
(ulong)keyid_from_pk( pk, NULL ),
datestr_from_pk( pk ) );
if( mainkey ) {
/* and now list all userids with their signatures */
for( node = node->next; node; node = node->next ) {
if( node->pkt->pkttype == PKT_SIGNATURE ) {
if( !any ) {
if( node->pkt->pkt.signature->sig_class == 0x20 )
puts("[revoked]");
else
putchar('\n');
any = 1;
}
list_node(c, node );
}
else if( node->pkt->pkttype == PKT_USER_ID ) {
if( any ) {
if( opt.with_colons )
printf("uid:::::::::");
else
printf( "uid%*s", 28, "" );
}
print_userid( node->pkt );
if( opt.with_colons )
putchar(':');
putchar('\n');
if( opt.fingerprint && !any )
print_fingerprint( pk, NULL );
any=1;
}
else if( node->pkt->pkttype == PKT_PUBLIC_SUBKEY ) {
if( !any ) {
putchar('\n');
any = 1;
}
list_node(c, node );
}
}
}
if( !any )
putchar('\n');
if( !mainkey && opt.fingerprint > 1 )
print_fingerprint( pk, NULL );
}
else if( (mainkey = (node->pkt->pkttype == PKT_SECRET_KEY) )
|| node->pkt->pkttype == PKT_SECRET_SUBKEY ) {
PKT_secret_key *sk = node->pkt->pkt.secret_key;
if( opt.with_colons ) {
u32 keyid[2];
keyid_from_sk( sk, keyid );
printf("%s::%u:%d:%08lX%08lX:%s:%s:::",
mainkey? "sec":"ssb",
nbits_from_sk( sk ),
sk->pubkey_algo,
(ulong)keyid[0],(ulong)keyid[1],
datestr_from_sk( sk ),
sk->expiredate? strtimestamp(sk->expiredate):""
/* fixme: add LID */ );
}
else
printf("%s %4u%c/%08lX %s ",
mainkey? "sec":"ssb",
nbits_from_sk( sk ),
pubkey_letter( sk->pubkey_algo ),
(ulong)keyid_from_sk( sk, NULL ),
datestr_from_sk( sk ) );
if( mainkey ) {
/* and now list all userids with their signatures */
for( node = node->next; node; node = node->next ) {
if( node->pkt->pkttype == PKT_SIGNATURE ) {
if( !any ) {
if( node->pkt->pkt.signature->sig_class == 0x20 )
puts("[revoked]");
else
putchar('\n');
any = 1;
}
list_node(c, node );
}
else if( node->pkt->pkttype == PKT_USER_ID ) {
if( any ) {
if( opt.with_colons )
printf("uid:::::::::");
else
printf( "uid%*s", 28, "" );
}
print_userid( node->pkt );
if( opt.with_colons )
putchar(':');
putchar('\n');
if( opt.fingerprint && !any )
print_fingerprint( NULL, sk );
any=1;
}
else if( node->pkt->pkttype == PKT_SECRET_SUBKEY ) {
if( !any ) {
putchar('\n');
any = 1;
}
list_node(c, node );
}
}
}
if( !any )
putchar('\n');
if( !mainkey && opt.fingerprint > 1 )
print_fingerprint( NULL, sk );
}
else if( node->pkt->pkttype == PKT_SIGNATURE ) {
PKT_signature *sig = node->pkt->pkt.signature;
int is_selfsig = 0;
int rc2=0;
size_t n;
char *p;
int sigrc = ' ';
if( !opt.list_sigs )
return;
if( sig->sig_class == 0x20 || sig->sig_class == 0x30 )
fputs("rev", stdout);
else
fputs("sig", stdout);
if( opt.check_sigs ) {
fflush(stdout);
switch( (rc2=do_check_sig( c, node, &is_selfsig )) ) {
case 0: sigrc = '!'; break;
case G10ERR_BAD_SIGN: sigrc = '-'; break;
case G10ERR_NO_PUBKEY: sigrc = '?'; break;
default: sigrc = '%'; break;
}
}
else { /* check whether this is a self signature */
u32 keyid[2];
if( c->list->pkt->pkttype == PKT_PUBLIC_KEY
|| c->list->pkt->pkttype == PKT_SECRET_KEY ) {
if( c->list->pkt->pkttype == PKT_PUBLIC_KEY )
keyid_from_pk( c->list->pkt->pkt.public_key, keyid );
else
keyid_from_sk( c->list->pkt->pkt.secret_key, keyid );
if( keyid[0] == sig->keyid[0] && keyid[1] == sig->keyid[1] )
is_selfsig = 1;
}
}
if( opt.with_colons ) {
putchar(':');
if( sigrc != ' ' )
putchar(sigrc);
printf(":::%08lX%08lX:%s::::", (ulong)sig->keyid[0],
(ulong)sig->keyid[1], datestr_from_sig(sig));
}
else
printf("%c %08lX %s ",
sigrc, (ulong)sig->keyid[1], datestr_from_sig(sig));
if( sigrc == '%' )
printf("[%s] ", g10_errstr(rc2) );
else if( sigrc == '?' )
;
else if( is_selfsig ) {
if( opt.with_colons )
putchar(':');
fputs( sig->sig_class == 0x18? "[keybind]":"[selfsig]", stdout);
if( opt.with_colons )
putchar(':');
}
else {
p = get_user_id( sig->keyid, &n );
print_string( stdout, p, n, opt.with_colons );
m_free(p);
}
if( opt.with_colons )
printf(":%02x:", sig->sig_class );
putchar('\n');
}
else
log_error("invalid node with packet of type %d\n", node->pkt->pkttype);
}
int
proc_packets( IOBUF a )
{
CTX c = m_alloc_clear( sizeof *c );
int rc = do_proc_packets( c, a );
m_free( c );
return rc;
}
int
proc_signature_packets( IOBUF a, STRLIST signedfiles, const char *sigfilename )
{
CTX c = m_alloc_clear( sizeof *c );
int rc;
c->sigs_only = 1;
c->signed_data = signedfiles;
c->sigfilename = sigfilename;
rc = do_proc_packets( c, a );
m_free( c );
return rc;
}
int
proc_encryption_packets( IOBUF a )
{
CTX c = m_alloc_clear( sizeof *c );
int rc;
c->encrypt_only = 1;
rc = do_proc_packets( c, a );
m_free( c );
return rc;
}
int
do_proc_packets( CTX c, IOBUF a )
{
PACKET *pkt = m_alloc( sizeof *pkt );
int rc=0;
int newpkt;
c->iobuf = a;
init_packet(pkt);
while( (rc=parse_packet(a, pkt)) != -1 ) {
if( rc ) {
free_packet(pkt);
if( rc == G10ERR_INVALID_PACKET )
break;
continue;
}
newpkt = -1;
if( opt.list_packets ) {
switch( pkt->pkttype ) {
case PKT_PUBKEY_ENC: proc_pubkey_enc( c, pkt ); break;
case PKT_ENCRYPTED: proc_encrypted( c, pkt ); break;
case PKT_COMPRESSED: proc_compressed( c, pkt ); break;
default: newpkt = 0; break;
}
}
else if( c->sigs_only ) {
switch( pkt->pkttype ) {
case PKT_PUBLIC_KEY:
case PKT_SECRET_KEY:
case PKT_USER_ID:
case PKT_SYMKEY_ENC:
case PKT_PUBKEY_ENC:
case PKT_ENCRYPTED:
rc = G10ERR_UNEXPECTED;
goto leave;
case PKT_SIGNATURE: newpkt = add_signature( c, pkt ); break;
case PKT_PLAINTEXT: proc_plaintext( c, pkt ); break;
case PKT_COMPRESSED: proc_compressed( c, pkt ); break;
case PKT_ONEPASS_SIG: newpkt = add_onepass_sig( c, pkt ); break;
default: newpkt = 0; break;
}
}
else if( c->encrypt_only ) {
switch( pkt->pkttype ) {
case PKT_PUBLIC_KEY:
case PKT_SECRET_KEY:
case PKT_USER_ID:
rc = G10ERR_UNEXPECTED;
goto leave;
case PKT_SIGNATURE: newpkt = add_signature( c, pkt ); break;
case PKT_SYMKEY_ENC: proc_symkey_enc( c, pkt ); break;
case PKT_PUBKEY_ENC: proc_pubkey_enc( c, pkt ); break;
case PKT_ENCRYPTED: proc_encrypted( c, pkt ); break;
case PKT_PLAINTEXT: proc_plaintext( c, pkt ); break;
case PKT_COMPRESSED: proc_compressed( c, pkt ); break;
case PKT_ONEPASS_SIG: newpkt = add_onepass_sig( c, pkt ); break;
default: newpkt = 0; break;
}
}
else {
switch( pkt->pkttype ) {
case PKT_PUBLIC_KEY:
case PKT_SECRET_KEY:
release_list( c );
c->list = new_kbnode( pkt );
newpkt = 1;
break;
case PKT_PUBLIC_SUBKEY:
case PKT_SECRET_SUBKEY:
newpkt = add_subkey( c, pkt );
break;
case PKT_USER_ID: newpkt = add_user_id( c, pkt ); break;
case PKT_SIGNATURE: newpkt = add_signature( c, pkt ); break;
case PKT_PUBKEY_ENC: proc_pubkey_enc( c, pkt ); break;
case PKT_SYMKEY_ENC: proc_symkey_enc( c, pkt ); break;
case PKT_ENCRYPTED: proc_encrypted( c, pkt ); break;
case PKT_PLAINTEXT: proc_plaintext( c, pkt ); break;
case PKT_COMPRESSED: proc_compressed( c, pkt ); break;
case PKT_ONEPASS_SIG: newpkt = add_onepass_sig( c, pkt ); break;
default: newpkt = 0; break;
}
}
if( pkt->pkttype != PKT_SIGNATURE )
c->have_data = pkt->pkttype == PKT_PLAINTEXT;
if( newpkt == -1 )
;
else if( newpkt ) {
pkt = m_alloc( sizeof *pkt );
init_packet(pkt);
}
else
free_packet(pkt);
}
rc = 0;
leave:
release_list( c );
m_free(c->dek);
free_packet( pkt );
m_free( pkt );
free_md_filter_context( &c->mfx );
return rc;
}
static void
print_keyid( FILE *fp, u32 *keyid )
{
size_t n;
char *p = get_user_id( keyid, &n );
print_string( fp, p, n, opt.with_colons );
m_free(p);
}
static int
check_sig_and_print( CTX c, KBNODE node )
{
PKT_signature *sig = node->pkt->pkt.signature;
const char *astr, *tstr;
int rc;
if( opt.skip_verify ) {
log_info(_("signature verification suppressed\n"));
return 0;
}
tstr = asctimestamp(sig->timestamp);
astr = pubkey_algo_to_string( sig->pubkey_algo );
log_info(_("Signature made %.*s using %s key ID %08lX\n"),
(int)strlen(tstr), tstr, astr? astr: "?", (ulong)sig->keyid[1] );
rc = do_check_sig(c, node, NULL );
if( !rc || rc == G10ERR_BAD_SIGN ) {
char *us = get_long_user_id_string( sig->keyid );
write_status_text( rc? STATUS_BADSIG : STATUS_GOODSIG, us );
m_free(us);
log_info(rc? _("BAD signature from \"")
: _("Good signature from \""));
print_keyid( stderr, sig->keyid );
putc('\"', stderr);
putc('\n', stderr);
if( !rc )
rc = check_signatures_trust( sig );
if( rc )
g10_errors_seen = 1;
if( opt.batch && rc )
g10_exit(1);
}
else {
write_status( STATUS_ERRSIG );
log_error(_("Can't check signature: %s\n"), g10_errstr(rc) );
}
return rc;
}
/****************
* Process the tree which starts at node
*/
static void
proc_tree( CTX c, KBNODE node )
{
KBNODE n1;
int rc;
if( opt.list_packets )
return;
c->local_id = 0;
c->trustletter = ' ';
if( node->pkt->pkttype == PKT_PUBLIC_KEY
|| node->pkt->pkttype == PKT_PUBLIC_SUBKEY ) {
merge_keys_and_selfsig( node );
list_node( c, node );
}
else if( node->pkt->pkttype == PKT_SECRET_KEY ) {
merge_keys_and_selfsig( node );
list_node( c, node );
}
else if( node->pkt->pkttype == PKT_ONEPASS_SIG ) {
/* check all signatures */
if( !c->have_data ) {
free_md_filter_context( &c->mfx );
/* prepare to create all requested message digests */
c->mfx.md = md_open(0, 0);
/* fixme: why looking for the signature packet and not 1passpacket*/
for( n1 = node; (n1 = find_next_kbnode(n1, PKT_SIGNATURE )); ) {
md_enable( c->mfx.md, n1->pkt->pkt.signature->digest_algo);
}
/* ask for file and hash it */
if( c->sigs_only )
rc = hash_datafiles( c->mfx.md, c->signed_data, c->sigfilename,
n1? (n1->pkt->pkt.onepass_sig->sig_class == 0x01):0 );
else
rc = ask_for_detached_datafile( &c->mfx,
iobuf_get_fname(c->iobuf));
if( rc ) {
log_error("can't hash datafile: %s\n", g10_errstr(rc));
return;
}
}
for( n1 = node; (n1 = find_next_kbnode(n1, PKT_SIGNATURE )); )
check_sig_and_print( c, n1 );
}
else if( node->pkt->pkttype == PKT_SIGNATURE ) {
PKT_signature *sig = node->pkt->pkt.signature;
if( !c->have_data ) {
free_md_filter_context( &c->mfx );
c->mfx.md = md_open(sig->digest_algo, 0);
if( c->sigs_only )
rc = hash_datafiles( c->mfx.md, c->signed_data, c->sigfilename,
sig->sig_class == 0x01 );
else
rc = ask_for_detached_datafile( &c->mfx,
iobuf_get_fname(c->iobuf));
if( rc ) {
log_error("can't hash datafile: %s\n", g10_errstr(rc));
return;
}
}
else
log_info(_("old style (PGP 2.x) signature\n"));
check_sig_and_print( c, node );
}
else
log_error(_("invalid root packet detected in proc_tree()\n"));
}
diff --git a/g10/misc.c b/g10/misc.c
index a52114748..e7990475b 100644
--- a/g10/misc.c
+++ b/g10/misc.c
@@ -1,247 +1,247 @@
/* misc.c - miscellaneous functions
* Copyright (C) 1998 Free Software Foundation, Inc.
*
* This file is part of GNUPG.
*
* GNUPG 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.
*
* GNUPG 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 <errno.h>
-#if defined(__linux__) && defined(__alpha__)
+#if defined(__linux__) && defined(__alpha__) && __GLIBC__ < 2
#include <asm/sysinfo.h>
#include <asm/unistd.h>
#endif
#ifdef HAVE_SETRLIMIT
#include <sys/time.h>
#include <sys/resource.h>
#endif
#include "util.h"
#include "main.h"
#include "options.h"
#include "i18n.h"
const char *g10m_revision_string(int);
const char *g10c_revision_string(int);
const char *g10u_revision_string(int);
volatile void
pull_in_libs(void)
{
g10m_revision_string(0);
g10c_revision_string(0);
g10u_revision_string(0);
}
-#if defined(__linux__) && defined(__alpha__) && defined(UAC_SIGBUS)
+#if defined(__linux__) && defined(__alpha__) && __GLIBC__ < 2
#warning using trap_unaligned
static int
setsysinfo(unsigned long op, void *buffer, unsigned long size,
int *start, void *arg, unsigned long flag)
{
return syscall(__NR_osf_setsysinfo, op, buffer, size, start, arg, flag);
}
void
trap_unaligned(void)
{
unsigned int buf[2];
buf[0] = SSIN_UACPROC;
buf[1] = UAC_SIGBUS | UAC_NOPRINT;
setsysinfo(SSI_NVPAIRS, buf, 1, 0, 0, 0);
}
#else
void
trap_unaligned(void)
{ /* dummy */
}
#endif
void
disable_core_dumps()
{
#ifdef HAVE_SETRLIMIT
struct rlimit limit;
limit.rlim_cur = 0;
limit.rlim_max = 0;
if( setrlimit( RLIMIT_CORE, &limit ) )
log_fatal(_("can't disable core dumps: %s\n"), strerror(errno) );
#else
log_info(_("WARNING: Program may create a core file!\n"));
#endif
}
u16
checksum_u16( unsigned n )
{
u16 a;
a = (n >> 8) & 0xff;
if( opt.emulate_bugs & EMUBUG_GPGCHKSUM ) {
a |= n & 0xff;
log_debug("csum_u16 emulated for n=%u\n", n);
}
else
a += n & 0xff;
return a;
}
static u16
checksum_u16_nobug( unsigned n )
{
u16 a;
a = (n >> 8) & 0xff;
a += n & 0xff;
return a;
}
u16
checksum( byte *p, unsigned n )
{
u16 a;
for(a=0; n; n-- )
a += *p++;
return a;
}
u16
checksum_mpi( MPI a )
{
u16 csum;
byte *buffer;
unsigned nbytes;
unsigned nbits;
buffer = mpi_get_buffer( a, &nbytes, NULL );
/* some versions of gpg encode wrong values for the length of an mpi
* so that mpi_get_nbits() which counts the mpi yields another (shorter)
* value than the one store with the mpi. mpi_get_nbit_info() returns
* this stored value if it is still available.
*/
if( opt.emulate_bugs & EMUBUG_GPGCHKSUM )
nbits = 0;
else
nbits = mpi_get_nbit_info(a);
if( !nbits )
nbits = mpi_get_nbits(a);
csum = checksum_u16( nbits );
csum += checksum( buffer, nbytes );
m_free( buffer );
return csum;
}
/****************
* This is the correct function
*/
u16
checksum_mpi_counted_nbits( MPI a )
{
u16 csum;
byte *buffer;
unsigned nbytes;
unsigned nbits;
buffer = mpi_get_buffer( a, &nbytes, NULL );
nbits = mpi_get_nbits(a);
mpi_set_nbit_info(a,nbits);
csum = checksum_u16_nobug( nbits );
csum += checksum( buffer, nbytes );
m_free( buffer );
return csum;
}
u32
buffer_to_u32( const byte *buffer )
{
unsigned long a;
a = *buffer << 24;
a |= buffer[1] << 16;
a |= buffer[2] << 8;
a |= buffer[3];
return a;
}
static void
no_exp_algo(void)
{
static int did_note = 0;
if( !did_note ) {
did_note = 1;
log_info(_("Experimental algorithms should not be used!\n"));
}
}
void
print_pubkey_algo_note( int algo )
{
if( algo >= 100 && algo <= 110 )
no_exp_algo();
else if( is_RSA( algo ) ) {
static int did_note = 0;
if( !did_note ) {
did_note = 1;
log_info(_("RSA keys are deprecated; please consider "
"creating a new key and use this key in the future\n"));
}
}
}
void
print_cipher_algo_note( int algo )
{
if( algo >= 100 && algo <= 110 )
no_exp_algo();
else if( algo == CIPHER_ALGO_3DES
|| algo == CIPHER_ALGO_CAST5
|| algo == CIPHER_ALGO_BLOWFISH
)
;
else {
static int did_note = 0;
if( !did_note ) {
did_note = 1;
log_info(_("This cipher algorithm is depreciated; "
"please use a more standard one!\n"));
}
}
}
void
print_digest_algo_note( int algo )
{
if( algo >= 100 && algo <= 110 )
no_exp_algo();
}
diff --git a/g10/options.h b/g10/options.h
index a8164f89d..b6b1cd2de 100644
--- a/g10/options.h
+++ b/g10/options.h
@@ -1,92 +1,93 @@
/* options.h
* Copyright (C) 1998 Free Software Foundation, Inc.
*
* This file is part of GNUPG.
*
* GNUPG 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.
*
* GNUPG 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
*/
#ifndef G10_OPTIONS_H
#define G10_OPTIONS_H
#undef ENABLE_COMMENT_PACKETS /* don't create comment packets */
struct {
int verbose;
int quiet;
unsigned debug;
int armor;
int compress;
char *outfile;
int textmode;
int batch; /* run in batch mode */
int answer_yes; /* answer yes on most questions */
int answer_no; /* answer no on most questions */
int check_sigs; /* check key signatures */
int with_colons;
int fingerprint; /* list fingerprints */
int list_sigs; /* list signatures */
int no_armor;
int list_packets; /* list-packets mode */
int def_cipher_algo;
int force_v3_sigs;
int def_digest_algo;
int def_compress_algo;
const char *def_secret_key;
int no_comment;
int marginals_needed;
int completes_needed;
int max_cert_depth;
const char *homedir;
int skip_verify;
int compress_keys;
int compress_sigs;
int always_trust;
int rfc1991;
unsigned emulate_bugs; /* bug emulation flags EMUBUG_xxxx */
int shm_coprocess;
const char *set_filename;
const char *comment_string;
int throw_keyid;
int s2k_mode;
int s2k_digest_algo;
int s2k_cipher_algo;
int not_dash_escaped;
+ int escape_from;
int lock_once;
} opt;
#define EMUBUG_GPGCHKSUM 1
#define DBG_PACKET_VALUE 1 /* debug packet reading/writing */
#define DBG_MPI_VALUE 2 /* debug mpi details */
#define DBG_CIPHER_VALUE 4 /* debug cipher handling */
/* (may reveal sensitive data) */
#define DBG_FILTER_VALUE 8 /* debug internal filter handling */
#define DBG_IOBUF_VALUE 16 /* debug iobuf stuff */
#define DBG_MEMORY_VALUE 32 /* debug memory allocation stuff */
#define DBG_CACHE_VALUE 64 /* debug the cacheing */
#define DBG_MEMSTAT_VALUE 128 /* show memory statistics */
#define DBG_TRUST_VALUE 256 /* debug the trustdb */
#define DBG_PACKET (opt.debug & DBG_PACKET_VALUE)
#define DBG_FILTER (opt.debug & DBG_FILTER_VALUE)
#define DBG_CACHE (opt.debug & DBG_CACHE_VALUE)
#define DBG_TRUST (opt.debug & DBG_TRUST_VALUE)
#endif /*G10_OPTIONS_H*/
diff --git a/g10/options.skel b/g10/options.skel
index 0e53339d5..82916826c 100644
--- a/g10/options.skel
+++ b/g10/options.skel
@@ -1,51 +1,58 @@
These first three lines are not copied to the options file in
the users home directory.
$Id$
# Options for GnuPG
#
# Unless you you specify which option file to use (with the
# commandline option "--options filename"), GnuPG uses the
# file ~/.gnupg/options by default.
#
# An option file can contain all long options which are
# available in GnuPG. If the first non white space character of
# a line is a '#', this line is ignored. Empty lines are also
# ignored.
#
# See the man page for a list of options.
# Uncomment the next line to get rid of the copyright notice
#no-greeting
# If you have more than 1 secret key in your keyring, you may want
# to uncomment the following option and set your preffered keyid
# default-key 621CC013
# The next option is enabled because this one is needed for interoperation
# with PGP 5 users. To enable full OpenPGP compliance you have to remove
# this option.
force-v3-sigs
+# Because some mailers change lines starting with "From " to ">From "
+# it is good to handle such lines in a special way when creating
+# cleartext signatures; all other PGP versions it this way too.
+# To enable full OpenPGP compliance you have to remove this option.
+
+escape_from_lines
+
# If you do not use the Latin-1 (ISO-8859-1) charset, you should
# tell GnuPG which is the native character set. Please check
# the man page for supported character sets.
#charset koi8-r
# You may define aliases like this:
# alias mynames -u 0x12345678 -u 0x456789ab -z 9
# everytime you use --mynames, it will be expanded to the options
# in the above defintion. The name of the alias may not be abbreviated.
# NOTE: This is not yet implemented
# lock the file only once for the lifetime of a process.
# if you do not define this, the lock will be obtained and released
# every time it is needed - normally this is not needed.
lock-once
# If you are not running one of the free operation systems
# you probably have to uncomment the next line:
#load-extension rndunix
diff --git a/g10/pkclist.c b/g10/pkclist.c
index 094842df3..fb0a89e7a 100644
--- a/g10/pkclist.c
+++ b/g10/pkclist.c
@@ -1,674 +1,709 @@
/* pkclist.c
* Copyright (C) 1998 Free Software Foundation, Inc.
*
* This file is part of GNUPG.
*
* GNUPG 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.
*
* GNUPG 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 <errno.h>
#include <assert.h>
#include "options.h"
#include "packet.h"
#include "errors.h"
#include "keydb.h"
#include "memory.h"
#include "util.h"
#include "trustdb.h"
#include "ttyio.h"
#include "status.h"
#include "i18n.h"
#define CONTROL_D ('D' - 'A' + 1)
static void
show_paths( ulong lid, int only_first )
{
void *context = NULL;
unsigned otrust, validity;
int last_level, level;
last_level = 0;
while( (level=enum_cert_paths( &context, &lid, &otrust, &validity)) != -1){
char *p;
int rc;
size_t n;
u32 keyid[2];
PKT_public_key *pk ;
if( level < last_level && only_first )
break;
last_level = level;
rc = keyid_from_lid( lid, keyid );
if( rc ) {
log_error("ooops: can't get keyid for lid %lu\n", lid);
return;
}
pk = m_alloc_clear( sizeof *pk );
rc = get_pubkey( pk, keyid );
if( rc ) {
log_error("key %08lX: public key not found: %s\n",
(ulong)keyid[1], g10_errstr(rc) );
return;
}
tty_printf("%*s%4u%c/%08lX.%lu %s \"",
level*2, "",
nbits_from_pk( pk ), pubkey_letter( pk->pubkey_algo ),
(ulong)keyid[1], lid, datestr_from_pk( pk ) );
+ #if 0
+ c = trust_letter(otrust);
+ if( c )
+ putchar( c );
+ else
+ printf( "%02x", otrust );
+ putchar('/');
+ c = trust_letter(validity);
+ if( c )
+ putchar( c );
+ else
+ printf( "%02x", validity );
+ putchar(' ');
+ #endif
+
+
p = get_user_id( keyid, &n );
tty_print_string( p, n ),
m_free(p);
tty_printf("\"\n");
free_public_key( pk );
}
enum_cert_paths( &context, NULL, NULL, NULL ); /* release context */
tty_printf("\n");
}
/****************
* Returns true if an ownertrust has changed.
*/
int
edit_ownertrust( ulong lid, int mode )
{
char *p;
int rc;
size_t n;
u32 keyid[2];
PKT_public_key *pk ;
int changed=0;
+ int quit=0;
rc = keyid_from_lid( lid, keyid );
if( rc ) {
log_error("ooops: can't get keyid for lid %lu\n", lid);
return 0;
}
pk = m_alloc_clear( sizeof *pk );
rc = get_pubkey( pk, keyid );
if( rc ) {
log_error("key %08lX: public key not found: %s\n",
(ulong)keyid[1], g10_errstr(rc) );
return 0;
}
if( !mode ) {
tty_printf(_("No trust value assigned to %lu:\n"
"%4u%c/%08lX %s \""), lid,
nbits_from_pk( pk ), pubkey_letter( pk->pubkey_algo ),
(ulong)keyid[1], datestr_from_pk( pk ) );
p = get_user_id( keyid, &n );
tty_print_string( p, n ),
m_free(p);
tty_printf("\"\n\n");
}
tty_printf(_(
"Please decide how far you trust this user to correctly\n"
"verify other users' keys (by looking at passports,\n"
"checking fingerprints from different sources...)?\n\n"
" 1 = Don't know\n"
" 2 = I do NOT trust\n"
" 3 = I trust marginally\n"
" 4 = I trust fully\n"
" s = please show me more information\n") );
if( mode )
tty_printf(_(" m = back to the main menu\n"));
+ else
+ tty_printf(_(" q = quit\n"));
tty_printf("\n");
for(;;) {
/* a string with valid answers */
- char *ans = _("sSmM");
+ char *ans = _("sSmMqQ");
- if( strlen(ans) != 4 )
+ if( strlen(ans) != 6 )
BUG();
p = cpr_get("edit_ownertrust.value",_("Your decision? "));
trim_spaces(p);
cpr_kill_prompt();
if( *p && p[1] )
;
else if( !p[1] && (*p >= '1' && *p <= '4') ) {
unsigned trust;
switch( *p ) {
case '1': trust = TRUST_UNDEFINED; break;
case '2': trust = TRUST_NEVER ; break;
case '3': trust = TRUST_MARGINAL ; break;
case '4': trust = TRUST_FULLY ; break;
default: BUG();
}
if( !update_ownertrust( lid, trust ) )
changed++;
break;
}
else if( *p == ans[0] || *p == ans[1] ) {
tty_printf(_(
"Certificates leading to an ultimately trusted key:\n"));
show_paths( lid, 1 );
}
else if( mode && (*p == ans[2] || *p == ans[3] || *p == CONTROL_D ) ) {
break ; /* back to the menu */
}
+ else if( !mode && (*p == ans[4] || *p == ans[5] ) ) {
+ quit = 1;
+ break ; /* back to the menu */
+ }
m_free(p); p = NULL;
}
m_free(p);
m_free(pk);
- return changed;
+ return quit? -1 : changed;
}
/****************
* Try to add some more owner trusts (interactive)
* Returns: -1 if no ownertrust were added.
*/
static int
-add_ownertrust( PKT_public_key *pk )
+add_ownertrust( PKT_public_key *pk, int *quit )
{
int rc;
void *context = NULL;
ulong lid;
unsigned otrust, validity;
int any=0, changed=0, any_undefined=0;
+ *quit = 0;
tty_printf(
_("Could not find a valid trust path to the key. Let's see whether we\n"
"can assign some missing owner trust values.\n\n"));
rc = query_trust_record( pk );
if( rc ) {
log_error("Ooops: not in trustdb\n");
return -1;
}
lid = pk->local_id;
while( enum_cert_paths( &context, &lid, &otrust, &validity ) != -1 ) {
+ if( lid == pk->local_id )
+ continue;
any=1;
if( otrust == TRUST_UNDEFINED || otrust == TRUST_EXPIRED ||
otrust == TRUST_UNKNOWN ) {
any_undefined=1;
- if( edit_ownertrust( lid, 0 ) )
- changed=1;
+ enum_cert_paths_print( &context, NULL, lid );
+ rc = edit_ownertrust( lid, 0 );
+ if( rc == -1 ) {
+ *quit = 1;
+ break;
+ }
+ else if( rc > 0 )
+ changed = 1;
}
}
enum_cert_paths( &context, NULL, NULL, NULL ); /* release context */
if( !any )
tty_printf(_("No path leading to one of our keys found.\n\n") );
else if( !any_undefined )
tty_printf(_("No certificates with undefined trust found.\n\n") );
else if( !changed )
tty_printf(_("No trust values changed.\n\n") );
return any? 0:-1;
}
/****************
* Check whether we can trust this pk which has a trustlevel of TRUSTLEVEL
* Returns: true if we trust.
*/
static int
do_we_trust( PKT_public_key *pk, int trustlevel )
{
int rc;
if( (trustlevel & TRUST_FLAG_REVOKED) ) {
log_info(_("key %08lX: key has been revoked!\n"),
(ulong)keyid_from_pk( pk, NULL) );
if( opt.batch )
return 0;
if( !cpr_get_answer_is_yes("revoked_key.override",
_("Use this key anyway? ")) )
return 0;
}
switch( (trustlevel & TRUST_MASK) ) {
case TRUST_UNKNOWN: /* No pubkey in trustDB: Insert and check again */
rc = insert_trust_record( pk );
if( rc ) {
log_error("failed to insert it into the trustdb: %s\n",
g10_errstr(rc) );
return 0; /* no */
}
rc = check_trust( pk, &trustlevel );
if( rc )
log_fatal("trust check after insert failed: %s\n",
g10_errstr(rc) );
if( trustlevel == TRUST_UNKNOWN || trustlevel == TRUST_EXPIRED )
BUG();
return do_we_trust( pk, trustlevel );
case TRUST_EXPIRED:
log_info(_("%08lX: key has expired\n"),
(ulong)keyid_from_pk( pk, NULL) );
return 0; /* no */
case TRUST_UNDEFINED:
if( opt.batch || opt.answer_no )
log_info(_("%08lX: no info to calculate a trust probability\n"),
(ulong)keyid_from_pk( pk, NULL) );
else {
- rc = add_ownertrust( pk );
- if( !rc ) {
+ int quit;
+
+ rc = add_ownertrust( pk, &quit );
+ if( !rc && !quit ) {
rc = check_trust( pk, &trustlevel );
if( rc )
log_fatal("trust check after add_ownertrust failed: %s\n",
g10_errstr(rc) );
/* fixme: this is recursive; we should unroll it */
return do_we_trust( pk, trustlevel );
}
}
return 0;
case TRUST_NEVER:
log_info(_("%08lX: We do NOT trust this key\n"),
(ulong)keyid_from_pk( pk, NULL) );
return 0; /* no */
case TRUST_MARGINAL:
log_info(
_("%08lX: It is not sure that this key really belongs to the owner\n"
"but it is accepted anyway\n"), (ulong)keyid_from_pk( pk, NULL) );
return 1; /* yes */
case TRUST_FULLY:
if( opt.verbose )
log_info(_("This key probably belongs to the owner\n"));
return 1; /* yes */
case TRUST_ULTIMATE:
if( opt.verbose )
log_info(_("This key belongs to us\n"));
return 1; /* yes */
default: BUG();
}
/* Eventuell fragen falls der trustlevel nicht ausreichend ist */
return 1; /* yes */
}
/****************
* wrapper around do_we_trust, so we can ask whether to use the
* key anyway.
*/
static int
do_we_trust_pre( PKT_public_key *pk, int trustlevel )
{
int rc = do_we_trust( pk, trustlevel );
if( !opt.batch && !rc ) {
tty_printf(_(
"It is NOT certain that the key belongs to its owner.\n"
"If you *really* know what you are doing, you may answer\n"
"the next question with yes\n\n") );
if( cpr_get_answer_is_yes("untrusted_key.override",
_("Use this key anyway? ")) )
rc = 1;
}
else if( opt.always_trust && !rc ) {
log_info(_("WARNING: Using untrusted key!\n"));
rc = 1;
}
return rc;
}
/****************
* Check whether we can trust this signature.
* Returns: Error if we shall not trust this signatures.
*/
int
check_signatures_trust( PKT_signature *sig )
{
PKT_public_key *pk = m_alloc_clear( sizeof *pk );
int trustlevel;
int dont_try = 0;
int rc=0;
rc = get_pubkey( pk, sig->keyid );
if( rc ) { /* this should not happen */
log_error("Ooops; the key vanished - can't check the trust\n");
rc = G10ERR_NO_PUBKEY;
goto leave;
}
retry:
rc = check_trust( pk, &trustlevel );
if( rc ) {
log_error("check trust failed: %s\n", g10_errstr(rc));
goto leave;
}
if( (trustlevel & TRUST_FLAG_REVOKED) ) {
write_status( STATUS_KEYREVOKED );
log_info(_("WARNING: This key has been revoked by its owner!\n"));
log_info(_(" This could mean that the signature is forgery.\n"));
}
switch( (trustlevel & TRUST_MASK) ) {
case TRUST_UNKNOWN: /* No pubkey in trustDB: Insert and check again */
rc = insert_trust_record( pk );
if( rc ) {
log_error("failed to insert it into the trustdb: %s\n",
g10_errstr(rc) );
goto leave;
}
rc = check_trust( pk, &trustlevel );
if( rc )
log_fatal("trust check after insert failed: %s\n",
g10_errstr(rc) );
if( trustlevel == TRUST_UNKNOWN || trustlevel == TRUST_EXPIRED )
BUG();
goto retry;
case TRUST_EXPIRED:
log_info(_("Note: This key has expired!\n"));
break;
case TRUST_UNDEFINED:
if( dont_try || opt.batch || opt.answer_no ) {
write_status( STATUS_TRUST_UNDEFINED );
log_info(_(
"WARNING: This key is not certified with a trusted signature!\n"));
log_info(_(
" There is no indication that the "
"signature belongs to the owner.\n" ));
}
else {
- rc = add_ownertrust( pk );
- if( rc ) {
+ int quit;
+ rc = add_ownertrust( pk, &quit );
+ if( rc || quit ) {
dont_try = 1;
rc = 0;
}
goto retry;
}
break;
case TRUST_NEVER:
write_status( STATUS_TRUST_NEVER );
log_info(_("WARNING: We do NOT trust this key!\n"));
log_info(_(" The signature is probably a FORGERY.\n"));
rc = G10ERR_BAD_SIGN;
break;
case TRUST_MARGINAL:
write_status( STATUS_TRUST_MARGINAL );
log_info(_(
"WARNING: This key is not certified with sufficiently trusted signatures!\n"
));
log_info(_(
" It is not certain that the signature belongs to the owner.\n"
));
break;
case TRUST_FULLY:
write_status( STATUS_TRUST_FULLY );
break;
case TRUST_ULTIMATE:
write_status( STATUS_TRUST_ULTIMATE );
break;
default: BUG();
}
leave:
free_public_key( pk );
return rc;
}
void
release_pk_list( PK_LIST pk_list )
{
PK_LIST pk_rover;
for( ; pk_list; pk_list = pk_rover ) {
pk_rover = pk_list->next;
free_public_key( pk_list->pk );
m_free( pk_list );
}
}
int
build_pk_list( STRLIST remusr, PK_LIST *ret_pk_list, unsigned usage )
{
PK_LIST pk_list = NULL;
PKT_public_key *pk=NULL;
int rc=0;
if( !remusr && !opt.batch ) { /* ask */
char *answer=NULL;
tty_printf(_(
"You did not specify a user ID. (you may use \"-r\")\n\n"));
for(;;) {
rc = 0;
m_free(answer);
answer = cpr_get_utf8("pklist.user_id.enter",
_("Enter the user ID: "));
trim_spaces(answer);
cpr_kill_prompt();
if( !*answer )
break;
if( pk )
free_public_key( pk );
pk = m_alloc_clear( sizeof *pk );
pk->pubkey_usage = usage;
rc = get_pubkey_byname( NULL, pk, answer, NULL );
if( rc )
tty_printf(_("No such user ID.\n"));
else if( !(rc=check_pubkey_algo2(pk->pubkey_algo, usage)) ) {
int trustlevel;
rc = check_trust( pk, &trustlevel );
if( rc ) {
log_error("error checking pk of '%s': %s\n",
answer, g10_errstr(rc) );
}
else if( do_we_trust_pre( pk, trustlevel ) ) {
PK_LIST r;
r = m_alloc( sizeof *r );
r->pk = pk; pk = NULL;
r->next = pk_list;
r->mark = 0;
pk_list = r;
break;
}
}
}
m_free(answer);
if( pk ) {
free_public_key( pk );
pk = NULL;
}
}
else {
for(; remusr; remusr = remusr->next ) {
pk = m_alloc_clear( sizeof *pk );
pk->pubkey_usage = usage;
if( (rc = get_pubkey_byname( NULL, pk, remusr->d, NULL )) ) {
free_public_key( pk ); pk = NULL;
log_error(_("%s: skipped: %s\n"), remusr->d, g10_errstr(rc) );
}
else if( !(rc=check_pubkey_algo2(pk->pubkey_algo, usage )) ) {
int trustlevel;
rc = check_trust( pk, &trustlevel );
if( rc ) {
free_public_key( pk ); pk = NULL;
log_error(_("%s: error checking key: %s\n"),
remusr->d, g10_errstr(rc) );
}
else if( do_we_trust_pre( pk, trustlevel ) ) {
/* note: do_we_trust may have changed the trustlevel */
PK_LIST r;
r = m_alloc( sizeof *r );
r->pk = pk; pk = NULL;
r->next = pk_list;
r->mark = 0;
pk_list = r;
}
else { /* we don't trust this pk */
free_public_key( pk ); pk = NULL;
}
}
else {
free_public_key( pk ); pk = NULL;
log_error(_("%s: skipped: %s\n"), remusr->d, g10_errstr(rc) );
}
}
}
if( !rc && !pk_list ) {
log_error(_("no valid addressees\n"));
rc = G10ERR_NO_USER_ID;
}
if( rc )
release_pk_list( pk_list );
else
*ret_pk_list = pk_list;
return rc;
}
/****************
* Return -1 if we could not find an algorithm.
*/
int
select_algo_from_prefs( PK_LIST pk_list, int preftype )
{
PK_LIST pkr;
u32 bits[8];
byte *pref = NULL;
size_t npref;
int i, j;
int compr_hack=0;
int any;
if( !pk_list )
return -1;
memset( bits, ~0, 8 * sizeof *bits );
for( pkr = pk_list; pkr; pkr = pkr->next ) {
u32 mask[8];
memset( mask, 0, 8 * sizeof *mask );
if( !pkr->pk->local_id )
BUG(); /* if this occurs, we can use get_ownertrust to set it */
if( preftype == PREFTYPE_SYM )
mask[0] |= (1<<2); /* 3DES is implicitly there */
m_free(pref);
pref = get_pref_data( pkr->pk->local_id, pkr->pk->namehash, &npref);
any = 0;
if( pref ) {
#if 0
log_hexdump("raw: ", pref, npref );
#endif
for(i=0; i+1 < npref; i+=2 ) {
if( pref[i] == preftype ) {
mask[pref[i+1]/32] |= 1 << (pref[i+1]%32);
any = 1;
}
}
}
if( (!pref || !any) && preftype == PREFTYPE_COMPR ) {
mask[0] |= 3; /* asume no_compression and old pgp */
compr_hack = 1;
}
#if 0
log_debug("mask=%08lX%08lX%08lX%08lX%08lX%08lX%08lX%08lX\n",
(ulong)mask[7], (ulong)mask[6], (ulong)mask[5], (ulong)mask[4],
(ulong)mask[3], (ulong)mask[2], (ulong)mask[1], (ulong)mask[0]);
#endif
for(i=0; i < 8; i++ )
bits[i] &= mask[i];
#if 0
log_debug("bits=%08lX%08lX%08lX%08lX%08lX%08lX%08lX%08lX\n",
(ulong)bits[7], (ulong)bits[6], (ulong)bits[5], (ulong)bits[4],
(ulong)bits[3], (ulong)bits[2], (ulong)bits[1], (ulong)bits[0]);
#endif
}
/* usable algorithms are now in bits
* We now use the last key from pk_list to select
* the algorithm we want to use. there are no
* preferences for the last key, we select the one
* corresponding to first set bit.
*/
i = -1;
any = 0;
if( pref ) {
for(j=0; j+1 < npref; j+=2 ) {
if( pref[j] == preftype ) {
any = 1;
if( (bits[pref[j+1]/32] & (1<<(pref[j+1]%32))) ) {
/* fixme: check whether this algoritm is available */
i = pref[j+1];
break;
}
}
}
}
if( !pref || !any ) {
for(j=0; j < 256; j++ )
if( (bits[j/32] & (1<<(j%32))) ) {
/* fixme: check whether this algoritm is available */
i = j;
break;
}
}
#if 0
log_debug("prefs of type %d: selected %d\n", preftype, i );
#endif
if( compr_hack && !i ) {
/* selected no compression, but we should check whether
* algorithm 1 is also available (the ordering is not relevant
* in this case). */
if( bits[0] & (1<<1) )
i = 1; /* yep; we can use compression algo 1 */
}
m_free(pref);
return i;
}
diff --git a/g10/plaintext.c b/g10/plaintext.c
index 7eda8df9d..d471b9fe3 100644
--- a/g10/plaintext.c
+++ b/g10/plaintext.c
@@ -1,314 +1,315 @@
/* plaintext.c - process an plaintext packet
* Copyright (C) 1998 Free Software Foundation, Inc.
*
* This file is part of GNUPG.
*
* GNUPG 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.
*
* GNUPG 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 <errno.h>
#include "util.h"
#include "memory.h"
#include "options.h"
#include "packet.h"
#include "ttyio.h"
#include "filter.h"
#include "main.h"
#include "status.h"
#include "i18n.h"
/****************
* Defer the last CR,LF
*/
static void
special_md_putc( MD_HANDLE md, int c, int *state )
{
if( c == -1 ) { /* flush */
if( *state == 1 ) {
md_putc(md, '\r');
}
+
*state = 0;
return;
}
again:
switch( *state ) {
case 0:
if( c == '\r' )
*state = 1;
else
md_putc(md, c );
break;
case 1:
if( c == '\n' )
*state = 2;
else {
md_putc(md, '\r');
*state = 0;
goto again;
}
break;
case 2:
md_putc(md, '\r');
md_putc(md, '\n');
*state = 0;
goto again;
default: BUG();
}
}
/****************
* Handle a plaintext packet. If MFX is not NULL, update the MDs
* Note: we should use the filter stuff here, but we have to add some
* easy mimic to set a read limit, so we calculate only the
* bytes from the plaintext.
*/
int
handle_plaintext( PKT_plaintext *pt, md_filter_context_t *mfx,
int nooutput, int clearsig )
{
char *fname = NULL;
FILE *fp = NULL;
int rc = 0;
int c;
int convert = pt->mode == 't';
int special_state = 0;
/* create the filename as C string */
if( nooutput )
;
else if( opt.outfile ) {
fname = m_alloc( strlen( opt.outfile ) + 1);
strcpy(fname, opt.outfile );
}
else if( pt->namelen == 8 && !memcmp( pt->name, "_CONSOLE", 8 ) ) {
log_info(_("data not saved; use option \"--output\" to save it\n"));
nooutput = 1;
}
else {
fname = m_alloc( pt->namelen +1 );
memcpy( fname, pt->name, pt->namelen );
fname[pt->namelen] = 0;
}
if( nooutput )
;
else if( !*fname || (*fname=='-' && !fname[1])) {
/* no filename or "-" given; write to stdout */
fp = stdout;
}
else if( !overwrite_filep( fname ) ) {
rc = G10ERR_CREATE_FILE;
goto leave;
}
if( fp || nooutput )
;
else if( !(fp = fopen(fname,"wb")) ) {
log_error("Error creating '%s': %s\n", fname, strerror(errno) );
rc = G10ERR_CREATE_FILE;
goto leave;
}
if( pt->len ) {
for( ; pt->len; pt->len-- ) {
if( (c = iobuf_get(pt->buf)) == -1 ) {
log_error("Problem reading source (%u bytes remaining)\n",
(unsigned)pt->len);
rc = G10ERR_READ_FILE;
goto leave;
}
if( mfx->md ) {
if( convert && clearsig )
special_md_putc(mfx->md, c, &special_state );
else
md_putc(mfx->md, c );
}
if( convert && !clearsig && c == '\r' )
continue; /* fixme: this hack might be too simple */
if( fp ) {
if( putc( c, fp ) == EOF ) {
log_error("Error writing to '%s': %s\n",
fname, strerror(errno) );
rc = G10ERR_WRITE_FILE;
goto leave;
}
}
}
}
else {
while( (c = iobuf_get(pt->buf)) != -1 ) {
if( mfx->md ) {
if( convert && clearsig )
special_md_putc(mfx->md, c, &special_state );
else
md_putc(mfx->md, c );
}
if( convert && !clearsig && c == '\r' )
continue; /* fixme: this hack might be too simple */
if( fp ) {
if( putc( c, fp ) == EOF ) {
log_error("Error writing to '%s': %s\n",
fname, strerror(errno) );
rc = G10ERR_WRITE_FILE;
goto leave;
}
}
}
iobuf_clear_eof(pt->buf);
}
if( mfx->md && convert && clearsig )
special_md_putc(mfx->md, -1, &special_state ); /* flush */
if( fp && fp != stdout && fclose(fp) ) {
log_error("Error closing '%s': %s\n", fname, strerror(errno) );
fp = NULL;
rc = G10ERR_WRITE_FILE;
goto leave;
}
fp = NULL;
leave:
if( fp && fp != stdout )
fclose(fp);
m_free(fname);
return rc;
}
/****************
* Ask for the detached datafile and calculate the digest from it.
* INFILE is the name of the input file.
*/
int
ask_for_detached_datafile( md_filter_context_t *mfx, const char *inname )
{
char *answer = NULL;
IOBUF fp;
int rc = 0;
int c;
fp = open_sigfile( inname ); /* open default file */
if( !fp && !opt.batch ) {
int any=0;
tty_printf("Detached signature.\n");
do {
m_free(answer);
answer = cpr_get("detached_signature.filename",
_("Please enter name of data file: "));
cpr_kill_prompt();
if( any && !*answer ) {
rc = G10ERR_READ_FILE;
goto leave;
}
fp = iobuf_open(answer);
if( !fp && errno == ENOENT ) {
tty_printf("No such file, try again or hit enter to quit.\n");
any++;
}
else if( !fp ) {
log_error("can't open '%s': %s\n", answer, strerror(errno) );
rc = G10ERR_READ_FILE;
goto leave;
}
} while( !fp );
}
if( !fp ) {
if( opt.verbose )
log_info(_("reading stdin ...\n"));
while( (c = getchar()) != EOF ) {
if( mfx->md )
md_putc(mfx->md, c );
}
}
else {
while( (c = iobuf_get(fp)) != -1 ) {
if( mfx->md )
md_putc(mfx->md, c );
}
iobuf_close(fp);
}
leave:
m_free(answer);
return rc;
}
static void
do_hash( MD_HANDLE md, IOBUF fp, int textmode )
{
text_filter_context_t tfx;
int c;
if( textmode ) {
memset( &tfx, 0, sizeof tfx);
iobuf_push_filter( fp, text_filter, &tfx );
}
while( (c = iobuf_get(fp)) != -1 )
md_putc(md, c );
}
/****************
* Hash the given files and append the hash to hash context md.
* If FILES is NULL, hash stdin.
*/
int
hash_datafiles( MD_HANDLE md, STRLIST files,
const char *sigfilename, int textmode )
{
IOBUF fp;
STRLIST sl=NULL;
if( !files ) {
/* check whether we can opne the signed material */
fp = open_sigfile( sigfilename );
if( fp ) {
do_hash( md, fp, textmode );
iobuf_close(fp);
return 0;
}
/* no we can't (no sigfile) - read signed stuff from stdin */
add_to_strlist( &sl, "-");
}
else
sl = files;
for( ; sl; sl = sl->next ) {
fp = iobuf_open( sl->d );
if( !fp ) {
log_error(_("can't open signed data '%s'\n"),
print_fname_stdin(sl->d));
if( !files )
free_strlist(sl);
return G10ERR_OPEN_FILE;
}
do_hash( md, fp, textmode );
iobuf_close(fp);
}
if( !files )
free_strlist(sl);
return 0;
}
diff --git a/g10/sign.c b/g10/sign.c
index 9b78acf7e..f3373ed4f 100644
--- a/g10/sign.c
+++ b/g10/sign.c
@@ -1,820 +1,843 @@
/* sign.c - sign data
* Copyright (C) 1998 Free Software Foundation, Inc.
*
* This file is part of GNUPG.
*
* GNUPG 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.
*
* GNUPG 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 <errno.h>
#include <assert.h>
#include "options.h"
#include "packet.h"
#include "errors.h"
#include "iobuf.h"
#include "keydb.h"
#include "memory.h"
#include "util.h"
#include "main.h"
#include "filter.h"
#include "ttyio.h"
#include "trustdb.h"
#include "i18n.h"
static int
do_sign( PKT_secret_key *sk, PKT_signature *sig,
MD_HANDLE md, int digest_algo )
{
MPI frame;
byte *dp;
int rc;
print_pubkey_algo_note(sk->pubkey_algo);
if( !digest_algo )
digest_algo = md_get_algo(md);
print_digest_algo_note( digest_algo );
dp = md_read( md, digest_algo );
sig->digest_algo = digest_algo;
sig->digest_start[0] = dp[0];
sig->digest_start[1] = dp[1];
frame = encode_md_value( sk->pubkey_algo, md,
digest_algo, mpi_get_nbits(sk->skey[0]));
rc = pubkey_sign( sk->pubkey_algo, sig->data, frame, sk->skey );
mpi_free(frame);
if( rc )
log_error(_("signing failed: %s\n"), g10_errstr(rc) );
else {
if( opt.verbose ) {
char *ustr = get_user_id_string( sig->keyid );
log_info(_("%s signature from: %s\n"),
pubkey_algo_to_string(sk->pubkey_algo), ustr );
m_free(ustr);
}
}
return rc;
}
int
complete_sig( PKT_signature *sig, PKT_secret_key *sk, MD_HANDLE md )
{
int rc=0;
if( !(rc=check_secret_key( sk, 0 )) )
rc = do_sign( sk, sig, md, 0 );
/* fixme: should we check whether the signature is okay?
* maybe by using an option */
return rc;
}
static int
hash_for(int pubkey_algo )
{
if( opt.def_digest_algo )
return opt.def_digest_algo;
if( pubkey_algo == PUBKEY_ALGO_DSA )
return DIGEST_ALGO_SHA1;
if( pubkey_algo == PUBKEY_ALGO_RSA )
return DIGEST_ALGO_MD5;
return DEFAULT_DIGEST_ALGO;
}
static int
only_old_style( SK_LIST sk_list )
{
SK_LIST sk_rover = NULL;
int old_style = 0;
/* if there are only old style capable key we use the old sytle */
for( sk_rover = sk_list; sk_rover; sk_rover = sk_rover->next ) {
PKT_secret_key *sk = sk_rover->sk;
if( sk->pubkey_algo == PUBKEY_ALGO_RSA && sk->version < 4 )
old_style = 1;
else
return 0;
}
return old_style;
}
/****************
* Sign the files whose names are in FILENAME.
* If DETACHED has the value true,
* make a detached signature. If FILENAMES->d is NULL read from stdin
* and ignore the detached mode. Sign the file with all secret keys
* which can be taken from LOCUSR, if this is NULL, use the default one
* If ENCRYPT is true, use REMUSER (or ask if it is NULL) to encrypt the
* signed data for these users.
* If OUTFILE is not NULL; this file is used for output and the function
* does not ask for overwrite permission; output is then always
* uncompressed, non-armored and in binary mode.
*/
int
sign_file( STRLIST filenames, int detached, STRLIST locusr,
int encrypt, STRLIST remusr, const char *outfile )
{
const char *fname;
armor_filter_context_t afx;
compress_filter_context_t zfx;
md_filter_context_t mfx;
text_filter_context_t tfx;
encrypt_filter_context_t efx;
IOBUF inp = NULL, out = NULL;
PACKET pkt;
PKT_plaintext *pt = NULL;
u32 filesize;
int rc = 0;
PK_LIST pk_list = NULL;
SK_LIST sk_list = NULL;
SK_LIST sk_rover = NULL;
int multifile = 0;
int old_style = opt.rfc1991;
int compr_algo = -1; /* unknown */
memset( &afx, 0, sizeof afx);
memset( &zfx, 0, sizeof zfx);
memset( &mfx, 0, sizeof mfx);
memset( &tfx, 0, sizeof tfx);
memset( &efx, 0, sizeof efx);
init_packet( &pkt );
if( filenames ) {
fname = filenames->d;
multifile = !!filenames->next;
}
else
fname = NULL;
if( fname && filenames->next && (!detached || encrypt) )
log_bug("multiple files can only be detached signed");
if( (rc=build_sk_list( locusr, &sk_list, 1, PUBKEY_USAGE_SIG )) )
goto leave;
if( !old_style )
old_style = only_old_style( sk_list );
if( encrypt ) {
if( (rc=build_pk_list( remusr, &pk_list, PUBKEY_USAGE_ENC )) )
goto leave;
if( !old_style )
compr_algo = select_algo_from_prefs( pk_list, PREFTYPE_COMPR );
}
/* prepare iobufs */
if( multifile ) /* have list of filenames */
inp = NULL; /* we do it later */
else if( !(inp = iobuf_open(fname)) ) {
log_error("can't open %s: %s\n", fname? fname: "[stdin]",
strerror(errno) );
rc = G10ERR_OPEN_FILE;
goto leave;
}
if( outfile ) {
if( !(out = iobuf_create( outfile )) ) {
log_error(_("can't create %s: %s\n"), outfile, strerror(errno) );
rc = G10ERR_CREATE_FILE;
goto leave;
}
else if( opt.verbose )
log_info(_("writing to '%s'\n"), outfile );
}
else if( (rc = open_outfile( fname, opt.armor? 1: detached? 2:0, &out )))
goto leave;
/* prepare to calculate the MD over the input */
if( opt.textmode && !outfile )
iobuf_push_filter( inp, text_filter, &tfx );
mfx.md = md_open(0, 0);
for( sk_rover = sk_list; sk_rover; sk_rover = sk_rover->next ) {
PKT_secret_key *sk = sk_rover->sk;
md_enable(mfx.md, hash_for(sk->pubkey_algo));
}
if( !multifile )
iobuf_push_filter( inp, md_filter, &mfx );
if( detached && !encrypt && !opt.rfc1991 )
afx.what = 2;
if( opt.armor && !outfile )
iobuf_push_filter( out, armor_filter, &afx );
#ifdef ENABLE_COMMENT_PACKETS
else {
write_comment( out, "#created by GNUPG v" VERSION " ("
PRINTABLE_OS_NAME ")");
if( opt.comment_string )
write_comment( out, opt.comment_string );
}
#endif
if( encrypt ) {
efx.pk_list = pk_list;
/* fixme: set efx.cfx.datalen if known */
iobuf_push_filter( out, encrypt_filter, &efx );
}
if( opt.compress && !outfile && ( !detached || opt.compress_sigs) ) {
if( !compr_algo )
; /* don't use compression */
else {
if( old_style || compr_algo == 1 )
zfx.algo = 1;
iobuf_push_filter( out, compress_filter, &zfx );
}
}
if( !detached && !old_style ) {
int skcount=0;
/* loop over the secret certificates and build headers
* The specs now say that the data should be bracket by
* the onepass-sig and signature-packet; so we must build it
* here in reverse order */
for( sk_rover = sk_list; sk_rover; sk_rover = sk_rover->next )
skcount++;
for( ; skcount; skcount-- ) {
PKT_secret_key *sk;
PKT_onepass_sig *ops;
int i = 0;
for( sk_rover = sk_list; sk_rover; sk_rover = sk_rover->next )
if( ++i == skcount )
break;
sk = sk_rover->sk;
ops = m_alloc_clear( sizeof *ops );
ops->sig_class = opt.textmode && !outfile ? 0x01 : 0x00;
ops->digest_algo = hash_for(sk->pubkey_algo);
ops->pubkey_algo = sk->pubkey_algo;
keyid_from_sk( sk, ops->keyid );
ops->last = skcount == 1;
init_packet(&pkt);
pkt.pkttype = PKT_ONEPASS_SIG;
pkt.pkt.onepass_sig = ops;
rc = build_packet( out, &pkt );
free_packet( &pkt );
if( rc ) {
log_error("build onepass_sig packet failed: %s\n",
g10_errstr(rc));
goto leave;
}
}
}
/* setup the inner packet */
if( detached ) {
if( multifile ) {
STRLIST sl;
if( opt.verbose )
log_info(_("signing:") );
/* must walk reverse trough this list */
for( sl = strlist_last(filenames); sl;
sl = strlist_prev( filenames, sl ) ) {
if( !(inp = iobuf_open(sl->d)) ) {
log_error(_("can't open %s: %s\n"),
sl->d, strerror(errno) );
rc = G10ERR_OPEN_FILE;
goto leave;
}
if( opt.verbose )
fprintf(stderr, " '%s'", sl->d );
iobuf_push_filter( inp, md_filter, &mfx );
while( iobuf_get(inp) != -1 )
;
iobuf_close(inp); inp = NULL;
}
if( opt.verbose )
putc( '\n', stderr );
}
else {
/* read, so that the filter can calculate the digest */
while( iobuf_get(inp) != -1 )
;
}
}
else {
if( fname || opt.set_filename ) {
char *s = make_basename( opt.set_filename ? opt.set_filename : fname );
pt = m_alloc( sizeof *pt + strlen(s) - 1 );
pt->namelen = strlen(s);
memcpy(pt->name, s, pt->namelen );
m_free(s);
}
else { /* no filename */
pt = m_alloc( sizeof *pt - 1 );
pt->namelen = 0;
}
if( fname ) {
if( !(filesize = iobuf_get_filelength(inp)) )
log_info(_("WARNING: '%s' is an empty file\n"), fname );
/* because the text_filter modifies the length of the
* data, it is not possible to know the used length
* without a double read of the file - to avoid that
* we simple use partial length packets.
* FIXME: We have to do the double read when opt.rfc1991
* is active.
*/
if( opt.textmode && !outfile )
filesize = 0;
}
else
filesize = 0; /* stdin */
pt->timestamp = make_timestamp();
pt->mode = opt.textmode && !outfile ? 't':'b';
pt->len = filesize;
pt->new_ctb = !pt->len && !opt.rfc1991;
pt->buf = inp;
pkt.pkttype = PKT_PLAINTEXT;
pkt.pkt.plaintext = pt;
/*cfx.datalen = filesize? calc_packet_length( &pkt ) : 0;*/
if( (rc = build_packet( out, &pkt )) )
log_error("build_packet(PLAINTEXT) failed: %s\n", g10_errstr(rc) );
pt->buf = NULL;
}
/* loop over the secret certificates */
for( sk_rover = sk_list; sk_rover; sk_rover = sk_rover->next ) {
PKT_secret_key *sk;
PKT_signature *sig;
MD_HANDLE md;
sk = sk_rover->sk;
/* build the signature packet */
/* fixme: this code is partly duplicated in make_keysig_packet */
sig = m_alloc_clear( sizeof *sig );
sig->version = old_style || opt.force_v3_sigs ? 3 : sk->version;
keyid_from_sk( sk, sig->keyid );
sig->digest_algo = hash_for(sk->pubkey_algo);
sig->pubkey_algo = sk->pubkey_algo;
sig->timestamp = make_timestamp();
sig->sig_class = opt.textmode && !outfile? 0x01 : 0x00;
md = md_copy( mfx.md );
if( sig->version >= 4 ) {
build_sig_subpkt_from_sig( sig );
md_putc( md, sig->version );
}
md_putc( md, sig->sig_class );
if( sig->version < 4 ) {
u32 a = sig->timestamp;
md_putc( md, (a >> 24) & 0xff );
md_putc( md, (a >> 16) & 0xff );
md_putc( md, (a >> 8) & 0xff );
md_putc( md, a & 0xff );
}
else {
byte buf[6];
size_t n;
md_putc( md, sig->pubkey_algo );
md_putc( md, sig->digest_algo );
if( sig->hashed_data ) {
n = (sig->hashed_data[0] << 8) | sig->hashed_data[1];
md_write( md, sig->hashed_data, n+2 );
n += 6;
}
else
n = 6;
/* add some magic */
buf[0] = sig->version;
buf[1] = 0xff;
buf[2] = n >> 24; /* hmmm, n is only 16 bit, so this is always 0 */
buf[3] = n >> 16;
buf[4] = n >> 8;
buf[5] = n;
md_write( md, buf, 6 );
}
md_final( md );
rc = do_sign( sk, sig, md, hash_for(sig->pubkey_algo) );
md_close( md );
if( !rc ) { /* and write it */
init_packet(&pkt);
pkt.pkttype = PKT_SIGNATURE;
pkt.pkt.signature = sig;
rc = build_packet( out, &pkt );
free_packet( &pkt );
if( rc )
log_error("build signature packet failed: %s\n", g10_errstr(rc) );
}
if( rc )
goto leave;
}
leave:
if( rc )
iobuf_cancel(out);
else
iobuf_close(out);
iobuf_close(inp);
md_close( mfx.md );
release_sk_list( sk_list );
release_pk_list( pk_list );
return rc;
}
/****************
* Note: We do not calculate the hash over the last CR,LF
*/
static int
write_dash_escaped( IOBUF inp, IOBUF out, MD_HANDLE md )
{
int c;
int lastlf = 1;
int state = 0;
if( opt.not_dash_escaped ) {
lastlf = 0;
while( (c = iobuf_get(inp)) != -1 ) {
md_putc(md, c );
iobuf_put( out, c );
lastlf = c;
}
if( lastlf != '\n' ) {
/* add a missing trailing LF */
md_putc(md, '\n' );
iobuf_put( out, '\n' );
}
return 0;
}
while( (c = iobuf_get(inp)) != -1 ) {
- /* Note: We don't escape "From " because the MUA should cope with it */
if( lastlf ) {
if( c == '-' ) {
iobuf_put( out, c );
iobuf_put( out, ' ' );
}
+ else if( c == 'F' && opt.escape_from ) {
+ int i;
+
+ if( state >= 1 )
+ md_putc(md, '\r');
+ if( state >= 2 )
+ md_putc(md, '\n');
+ state = 0;
+
+ for( i=1; i < 5 && (c = iobuf_get(inp)) != -1; i++ ) {
+ if( "From "[i] != c )
+ break;
+ }
+ if( i < 5 ) {
+ iobuf_write( out, "From", i );
+ md_write( md, "From", i );
+ if( c == -1 )
+ break;
+ }
+ else {
+ iobuf_writestr( out, "- From" );
+ md_write( md, "From", 4 );
+ }
+ }
}
again:
switch( state ) {
case 0:
if( c == '\r' )
state = 1;
else
md_putc(md, c );
break;
case 1:
if( c == '\n' )
state = 2;
else {
md_putc(md, '\r');
state = 0;
goto again;
}
break;
case 2:
md_putc(md, '\r');
md_putc(md, '\n');
state = 0;
goto again;
default: BUG();
}
iobuf_put( out, c );
lastlf = c == '\n';
}
if( state == 1 )
md_putc(md, '\r');
else if( state == 2 ) { /* file ended with a new line */
md_putc(md, '\r');
md_putc(md, '\n');
iobuf_put( out, '\n');
}
if( !lastlf )
iobuf_put( out, '\n' );
return 0; /* fixme: add error handling */
}
/****************
* make a clear signature. note that opt.armor is not needed
*/
int
clearsign_file( const char *fname, STRLIST locusr, const char *outfile )
{
armor_filter_context_t afx;
text_filter_context_t tfx;
MD_HANDLE textmd = NULL;
IOBUF inp = NULL, out = NULL;
PACKET pkt;
int rc = 0;
SK_LIST sk_list = NULL;
SK_LIST sk_rover = NULL;
int old_style = opt.rfc1991;
int only_md5 = 0;
memset( &afx, 0, sizeof afx);
memset( &tfx, 0, sizeof tfx);
init_packet( &pkt );
if( (rc=build_sk_list( locusr, &sk_list, 1, PUBKEY_USAGE_SIG )) )
goto leave;
if( !old_style )
old_style = only_old_style( sk_list );
/* prepare iobufs */
if( !(inp = iobuf_open(fname)) ) {
log_error("can't open %s: %s\n", fname? fname: "[stdin]",
strerror(errno) );
rc = G10ERR_OPEN_FILE;
goto leave;
}
if( outfile ) {
if( !(out = iobuf_create( outfile )) ) {
log_error(_("can't create %s: %s\n"), outfile, strerror(errno) );
rc = G10ERR_CREATE_FILE;
goto leave;
}
else if( opt.verbose )
log_info(_("writing to '%s'\n"), outfile );
}
else if( (rc = open_outfile( fname, 1, &out )) )
goto leave;
iobuf_writestr(out, "-----BEGIN PGP SIGNED MESSAGE-----\n" );
for( sk_rover = sk_list; sk_rover; sk_rover = sk_rover->next ) {
PKT_secret_key *sk = sk_rover->sk;
if( hash_for(sk->pubkey_algo) == DIGEST_ALGO_MD5 )
only_md5 = 1;
else {
only_md5 = 0;
break;
}
}
if( old_style || only_md5 )
iobuf_writestr(out, "\n" );
else {
const char *s;
int any = 0;
iobuf_writestr(out, "Hash: " );
for( sk_rover = sk_list; sk_rover; sk_rover = sk_rover->next ) {
PKT_secret_key *sk = sk_rover->sk;
s = digest_algo_to_string( hash_for(sk->pubkey_algo) );
if( s ) {
if( any )
iobuf_put(out, ',' );
iobuf_writestr(out, s );
any = 1;
}
}
assert(any);
iobuf_writestr(out, "\n" );
if( opt.not_dash_escaped )
iobuf_writestr( out,
"NotDashEscaped: You need GnuPG to verify this message\n" );
iobuf_writestr(out, "\n" );
}
textmd = md_open(0, 0);
for( sk_rover = sk_list; sk_rover; sk_rover = sk_rover->next ) {
PKT_secret_key *sk = sk_rover->sk;
md_enable(textmd, hash_for(sk->pubkey_algo));
}
- /*md_start_debug( textmd, "create" );*/
+ md_start_debug( textmd, "create" );
if( !opt.not_dash_escaped )
iobuf_push_filter( inp, text_filter, &tfx );
rc = write_dash_escaped( inp, out, textmd );
if( rc )
goto leave;
afx.what = 2;
iobuf_push_filter( out, armor_filter, &afx );
/* loop over the secret certificates */
for( sk_rover = sk_list; sk_rover; sk_rover = sk_rover->next ) {
PKT_secret_key *sk;
PKT_signature *sig;
MD_HANDLE md;
sk = sk_rover->sk;
/* build the signature packet */
/* fixme: this code is duplicated above */
sig = m_alloc_clear( sizeof *sig );
sig->version = old_style || opt.force_v3_sigs ? 3 : sk->version;
keyid_from_sk( sk, sig->keyid );
sig->digest_algo = hash_for(sk->pubkey_algo);
sig->pubkey_algo = sk->pubkey_algo;
sig->timestamp = make_timestamp();
sig->sig_class = 0x01;
md = md_copy( textmd );
if( sig->version >= 4 ) {
build_sig_subpkt_from_sig( sig );
md_putc( md, sig->version );
}
md_putc( md, sig->sig_class );
if( sig->version < 4 ) {
u32 a = sig->timestamp;
md_putc( md, (a >> 24) & 0xff );
md_putc( md, (a >> 16) & 0xff );
md_putc( md, (a >> 8) & 0xff );
md_putc( md, a & 0xff );
}
else {
byte buf[6];
size_t n;
md_putc( md, sig->pubkey_algo );
md_putc( md, sig->digest_algo );
if( sig->hashed_data ) {
n = (sig->hashed_data[0] << 8) | sig->hashed_data[1];
md_write( md, sig->hashed_data, n+2 );
n += 6;
}
else
n = 6;
/* add some magic */
buf[0] = sig->version;
buf[1] = 0xff;
buf[2] = n >> 24; /* hmmm, n is only 16 bit, so this is always 0 */
buf[3] = n >> 16;
buf[4] = n >> 8;
buf[5] = n;
md_write( md, buf, 6 );
}
md_final( md );
rc = do_sign( sk, sig, md, hash_for(sig->pubkey_algo) );
md_close( md );
if( !rc ) { /* and write it */
init_packet(&pkt);
pkt.pkttype = PKT_SIGNATURE;
pkt.pkt.signature = sig;
rc = build_packet( out, &pkt );
free_packet( &pkt );
if( rc )
log_error("build signature packet failed: %s\n", g10_errstr(rc) );
}
if( rc )
goto leave;
}
leave:
if( rc )
iobuf_cancel(out);
else
iobuf_close(out);
iobuf_close(inp);
md_close( textmd );
release_sk_list( sk_list );
return rc;
}
/****************
* Create a signature packet for the given public key certificate
* and the user id and return it in ret_sig. User signature class SIGCLASS
* user-id is not used (and may be NULL if sigclass is 0x20)
* If digest_algo is 0 the function selects an appropriate one.
*/
int
make_keysig_packet( PKT_signature **ret_sig, PKT_public_key *pk,
PKT_user_id *uid, PKT_public_key *subpk,
PKT_secret_key *sk,
int sigclass, int digest_algo,
int (*mksubpkt)(PKT_signature *, void *), void *opaque
)
{
PKT_signature *sig;
int rc=0;
MD_HANDLE md;
assert( (sigclass >= 0x10 && sigclass <= 0x13)
|| sigclass == 0x20 || sigclass == 0x18 );
if( !digest_algo ) {
switch( sk->pubkey_algo ) {
case PUBKEY_ALGO_DSA: digest_algo = DIGEST_ALGO_SHA1; break;
case PUBKEY_ALGO_RSA_S:
case PUBKEY_ALGO_RSA: digest_algo = DIGEST_ALGO_MD5; break;
default: digest_algo = DIGEST_ALGO_RMD160; break;
}
}
md = md_open( digest_algo, 0 );
/* hash the public key certificate and the user id */
hash_public_key( md, pk );
if( sigclass == 0x18 ) { /* subkey binding */
hash_public_key( md, subpk );
}
else if( sigclass != 0x20 ) {
if( sk->version >=4 ) {
byte buf[5];
buf[0] = 0xb4; /* indicates a userid packet */
buf[1] = uid->len >> 24; /* always use 4 length bytes */
buf[2] = uid->len >> 16;
buf[3] = uid->len >> 8;
buf[4] = uid->len;
md_write( md, buf, 5 );
}
md_write( md, uid->name, uid->len );
}
/* and make the signature packet */
sig = m_alloc_clear( sizeof *sig );
sig->version = sk->version;
keyid_from_sk( sk, sig->keyid );
sig->pubkey_algo = sk->pubkey_algo;
sig->digest_algo = digest_algo;
sig->timestamp = make_timestamp();
sig->sig_class = sigclass;
if( sig->version >= 4 )
build_sig_subpkt_from_sig( sig );
if( sig->version >= 4 && mksubpkt )
rc = (*mksubpkt)( sig, opaque );
if( !rc ) {
if( sig->version >= 4 )
md_putc( md, sig->version );
md_putc( md, sig->sig_class );
if( sig->version < 4 ) {
u32 a = sig->timestamp;
md_putc( md, (a >> 24) & 0xff );
md_putc( md, (a >> 16) & 0xff );
md_putc( md, (a >> 8) & 0xff );
md_putc( md, a & 0xff );
}
else {
byte buf[6];
size_t n;
md_putc( md, sig->pubkey_algo );
md_putc( md, sig->digest_algo );
if( sig->hashed_data ) {
n = (sig->hashed_data[0] << 8) | sig->hashed_data[1];
md_write( md, sig->hashed_data, n+2 );
n += 6;
}
else
n = 6;
/* add some magic */
buf[0] = sig->version;
buf[1] = 0xff;
buf[2] = n >> 24; /* hmmm, n is only 16 bit, so this is always 0 */
buf[3] = n >> 16;
buf[4] = n >> 8;
buf[5] = n;
md_write( md, buf, 6 );
}
md_final(md);
rc = complete_sig( sig, sk, md );
}
md_close( md );
if( rc )
free_seckey_enc( sig );
else
*ret_sig = sig;
return rc;
}
diff --git a/g10/trustdb.c b/g10/trustdb.c
index fbfb807ac..ff05a32ac 100644
--- a/g10/trustdb.c
+++ b/g10/trustdb.c
@@ -1,3041 +1,3108 @@
/* trustdb.c
* Copyright (C) 1998 Free Software Foundation, Inc.
*
* This file is part of GNUPG.
*
* GNUPG 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.
*
* GNUPG 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 <errno.h>
#include <ctype.h>
#include <assert.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>
#include "errors.h"
#include "iobuf.h"
#include "keydb.h"
#include "memory.h"
#include "util.h"
#include "trustdb.h"
#include "options.h"
#include "packet.h"
#include "main.h"
#include "i18n.h"
#include "tdbio.h"
#if MAX_FINGERPRINT_LEN > 20
#error Must change structure of trustdb
#endif
struct keyid_list {
struct keyid_list *next;
u32 keyid[2];
};
struct local_id_item {
struct local_id_item *next;
ulong lid;
unsigned flag;
};
struct local_id_table {
struct local_id_table *next; /* only used to keep a list of unused tables */
struct local_id_item *items[16];
};
typedef struct local_id_table *LOCAL_ID_TABLE;
typedef struct trust_info TRUST_INFO;
struct trust_info {
ulong lid;
byte otrust; /* ownertrust (assigned trust) */
byte trust; /* calculated trust (validity) */
};
typedef struct trust_seg_list *TRUST_SEG_LIST;
struct trust_seg_list {
TRUST_SEG_LIST next;
int pathlen;
TRUST_INFO path[1];
};
+struct enum_cert_paths_ctx {
+ int init;
+ TRUST_SEG_LIST tsl_head;
+ TRUST_SEG_LIST tsl;
+ int idx;
+};
+
struct recno_list_struct {
struct recno_list_struct *next;
ulong recno;
int type;
};
typedef struct recno_list_struct *RECNO_LIST;
static int walk_sigrecs( SIGREC_CONTEXT *c );
static LOCAL_ID_TABLE new_lid_table(void);
static void release_lid_table( LOCAL_ID_TABLE tbl );
static int ins_lid_table_item( LOCAL_ID_TABLE tbl, ulong lid, unsigned flag );
static int qry_lid_table_flag( LOCAL_ID_TABLE tbl, ulong lid, unsigned *flag );
static void print_user_id( const char *text, u32 *keyid );
+static void sort_tsl_list( TRUST_SEG_LIST *trust_seg_list );
static int list_sigs( ulong pubkey_id );
static int do_check( TRUSTREC *drec, unsigned *trustlevel );
static int get_dir_record( PKT_public_key *pk, TRUSTREC *rec );
static void upd_pref_record( TRUSTREC *urec, u32 *keyid, PKT_signature *sig );
static void upd_cert_record( KBNODE keyblock, KBNODE signode, u32 *keyid,
TRUSTREC *drec, RECNO_LIST *recno_list, int recheck,
TRUSTREC *urec, const byte *uidhash, int revoke );
static struct keyid_list *trusted_key_list;
/* a table used to keep track of ultimately trusted keys
* which are the ones from our secrings and the trusted keys */
static LOCAL_ID_TABLE ultikey_table;
/* list of unused lid items and tables */
static LOCAL_ID_TABLE unused_lid_tables;
static struct local_id_item *unused_lid_items;
#define HEXTOBIN(a) ( (a) >= '0' && (a) <= '9' ? ((a)-'0') : \
(a) >= 'A' && (a) <= 'F' ? ((a)-'A'+10) : ((a)-'a'+10))
/**********************************************
*********** record read write **************
**********************************************/
static void
die_invalid_db()
{
log_error(_(
"The trust DB is corrupted; please run \"gpgm --fix-trust-db\".\n") );
g10_exit(2);
}
/****************
* Read a record but die if it does not exist
*/
static void
read_record( ulong recno, TRUSTREC *rec, int rectype )
{
int rc = tdbio_read_record( recno, rec, rectype );
if( !rc )
return;
log_error(_("trust record %lu, req type %d: read failed: %s\n"),
recno, rectype, g10_errstr(rc) );
die_invalid_db();
}
/****************
* Wirte a record but die on error
*/
static void
write_record( TRUSTREC *rec )
{
int rc = tdbio_write_record( rec );
if( !rc )
return;
log_error(_("trust record %lu, type %d: write failed: %s\n"),
rec->recnum, rec->rectype, g10_errstr(rc) );
die_invalid_db();
}
/****************
* Delete a record but die on error
*/
static void
delete_record( ulong recno )
{
int rc = tdbio_delete_record( recno );
if( !rc )
return;
log_error(_("trust record %lu: delete failed: %s\n"),
recno, g10_errstr(rc) );
die_invalid_db();
}
/****************
* sync the db
*/
static void
do_sync( )
{
int rc = tdbio_sync();
if( !rc )
return;
log_error(_("trust db: sync failed: %s\n"), g10_errstr(rc) );
g10_exit(2);
}
/**********************************************
************* list helpers *******************
**********************************************/
/****************
* Insert a new item into a recno list
*/
static void
ins_recno_list( RECNO_LIST *head, ulong recno, int type )
{
RECNO_LIST item = m_alloc( sizeof *item );
item->recno = recno;
item->type = type;
item->next = *head;
*head = item;
}
static RECNO_LIST
qry_recno_list( RECNO_LIST list, ulong recno, int type )
{
for( ; list; list = list->next ) {
if( list->recno == recno && (!type || list->type == type) )
return list;
}
return NULL;
}
static void
rel_recno_list( RECNO_LIST *head )
{
RECNO_LIST r, r2;
for(r = *head; r; r = r2 ) {
r2 = r->next;
m_free(r);
}
*head = NULL;
}
static LOCAL_ID_TABLE
new_lid_table(void)
{
LOCAL_ID_TABLE a;
a = unused_lid_tables;
if( a ) {
unused_lid_tables = a->next;
memset( a, 0, sizeof *a );
}
else
a = m_alloc_clear( sizeof *a );
return a;
}
static void
release_lid_table( LOCAL_ID_TABLE tbl )
{
struct local_id_item *a, *a2;
int i;
for(i=0; i < 16; i++ ) {
for(a=tbl->items[i]; a; a = a2 ) {
a2 = a->next;
a->next = unused_lid_items;
unused_lid_items = a;
}
}
tbl->next = unused_lid_tables;
unused_lid_tables = tbl;
}
/****************
* Add a new item to the table or return 1 if we already have this item
*/
static int
ins_lid_table_item( LOCAL_ID_TABLE tbl, ulong lid, unsigned flag )
{
struct local_id_item *a;
for( a = tbl->items[lid & 0x0f]; a; a = a->next )
if( a->lid == lid )
return 1;
a = unused_lid_items;
if( a )
unused_lid_items = a->next;
else
a = m_alloc( sizeof *a );
a->lid = lid;
a->flag = flag;
a->next = tbl->items[lid & 0x0f];
tbl->items[lid & 0x0f] = a;
return 0;
}
static int
qry_lid_table_flag( LOCAL_ID_TABLE tbl, ulong lid, unsigned *flag )
{
struct local_id_item *a;
for( a = tbl->items[lid & 0x0f]; a; a = a->next )
if( a->lid == lid ) {
if( flag )
*flag = a->flag;
return 0;
}
return -1;
}
/****************
* Return the keyid from the primary key identified by LID.
*/
int
keyid_from_lid( ulong lid, u32 *keyid )
{
TRUSTREC rec;
int rc;
rc = tdbio_read_record( lid, &rec, 0 );
if( rc ) {
log_error(_("error reading dir record for LID %lu: %s\n"),
lid, g10_errstr(rc));
return G10ERR_TRUSTDB;
}
if( rec.rectype == RECTYPE_SDIR )
return 0;
if( rec.rectype != RECTYPE_DIR ) {
log_error(_("lid %lu: expected dir record, got type %d\n"),
lid, rec.rectype );
return G10ERR_TRUSTDB;
}
if( !rec.r.dir.keylist ) {
log_error(_("no primary key for LID %lu\n"), lid );
return G10ERR_TRUSTDB;
}
rc = tdbio_read_record( rec.r.dir.keylist, &rec, RECTYPE_KEY );
if( rc ) {
log_error(_("error reading primary key for LID %lu: %s\n"),
lid, g10_errstr(rc));
return G10ERR_TRUSTDB;
}
keyid_from_fingerprint( rec.r.key.fingerprint, rec.r.key.fingerprint_len,
keyid );
return 0;
}
ulong
lid_from_keyblock( KBNODE keyblock )
{
KBNODE node = find_kbnode( keyblock, PKT_PUBLIC_KEY );
PKT_public_key *pk;
if( !node )
BUG();
pk = node->pkt->pkt.public_key;
if( !pk->local_id ) {
TRUSTREC rec;
get_dir_record( pk, &rec );
}
return pk->local_id;
}
/****************
* Walk through the signatures of a public key.
* The caller must provide a context structure, with all fields set
* to zero, but the local_id field set to the requested key;
* This function does not change this field. On return the context
* is filled with the local-id of the signature and the signature flag.
* No fields should be changed (clearing all fields and setting
* pubkeyid is okay to continue with an other pubkey)
* Returns: 0 - okay, -1 for eof (no more sigs) or any other errorcode
*/
static int
walk_sigrecs( SIGREC_CONTEXT *c )
{
TRUSTREC *r;
ulong rnum;
if( c->ctl.eof )
return -1;
r = &c->ctl.rec;
if( !c->ctl.init_done ) {
c->ctl.init_done = 1;
read_record( c->lid, r, 0 );
if( r->rectype != RECTYPE_DIR ) {
c->ctl.eof = 1;
return -1; /* return eof */
}
c->ctl.nextuid = r->r.dir.uidlist;
/* force a read */
c->ctl.index = SIGS_PER_RECORD;
r->r.sig.next = 0;
}
/* need a loop to skip over deleted sigs */
do {
if( c->ctl.index >= SIGS_PER_RECORD ) { /* read the record */
rnum = r->r.sig.next;
if( !rnum && c->ctl.nextuid ) { /* read next uid record */
read_record( c->ctl.nextuid, r, RECTYPE_UID );
c->ctl.nextuid = r->r.uid.next;
rnum = r->r.uid.siglist;
}
if( !rnum ) {
c->ctl.eof = 1;
return -1; /* return eof */
}
read_record( rnum, r, RECTYPE_SIG );
if( r->r.sig.lid != c->lid ) {
log_error(_("chained sigrec %lu has a wrong owner\n"), rnum );
c->ctl.eof = 1;
die_invalid_db();
}
c->ctl.index = 0;
}
} while( !r->r.sig.sig[c->ctl.index++].lid );
c->sig_lid = r->r.sig.sig[c->ctl.index-1].lid;
c->sig_flag = r->r.sig.sig[c->ctl.index-1].flag;
return 0;
}
/***********************************************
************* Trust stuff ******************
***********************************************/
static int
trust_letter( unsigned value )
{
switch( value ) {
case TRUST_UNKNOWN: return '-';
case TRUST_EXPIRED: return 'e';
case TRUST_UNDEFINED: return 'q';
case TRUST_NEVER: return 'n';
case TRUST_MARGINAL: return 'm';
case TRUST_FULLY: return 'f';
case TRUST_ULTIMATE: return 'u';
default: return 0 ;
}
}
void
register_trusted_key( const char *string )
{
u32 keyid[2];
struct keyid_list *r;
if( classify_user_id( string, keyid, NULL, NULL, NULL ) != 11 ) {
log_error(_("'%s' is not a valid long keyID\n"), string );
return;
}
for( r = trusted_key_list; r; r = r->next )
if( r->keyid[0] == keyid[0] && r->keyid[1] == keyid[1] )
return;
r = m_alloc( sizeof *r );
r->keyid[0] = keyid[0];
r->keyid[1] = keyid[1];
r->next = trusted_key_list;
trusted_key_list = r;
}
/****************
* Verify that all our public keys are in the trustdb.
*/
static int
verify_own_keys()
{
int rc;
void *enum_context = NULL;
PKT_secret_key *sk = m_alloc_clear( sizeof *sk );
PKT_public_key *pk = m_alloc_clear( sizeof *pk );
u32 keyid[2];
struct keyid_list *kl;
/* put the trusted keys into the trusted key table */
for( kl = trusted_key_list; kl; kl = kl->next ) {
keyid[0] = kl->keyid[0];
keyid[1] = kl->keyid[1];
/* get the public key */
memset( pk, 0, sizeof *pk );
rc = get_pubkey( pk, keyid );
if( rc ) {
log_info(_("key %08lX: no public key for trusted key - skipped\n"),
(ulong)keyid[1] );
}
else {
/* make sure that the pubkey is in the trustdb */
rc = query_trust_record( pk );
if( rc == -1 ) { /* put it into the trustdb */
rc = insert_trust_record( pk );
if( rc ) {
log_error(_("key %08lX: can't put it into the trustdb\n"),
(ulong)keyid[1] );
}
}
else if( rc ) {
log_error(_("key %08lX: query record failed\n"),
(ulong)keyid[1] );
}
else {
if( ins_lid_table_item( ultikey_table, pk->local_id, 0 ) )
log_error(_("key %08lX: already in trusted key table\n"),
(ulong)keyid[1]);
else if( opt.verbose > 1 )
log_info(_("key %08lX: accepted as trusted key.\n"),
(ulong)keyid[1]);
}
}
release_public_key_parts( pk );
}
while( !(rc=enum_secret_keys( &enum_context, sk, 0 ) ) ) {
int have_pk = 0;
keyid_from_sk( sk, keyid );
if( DBG_TRUST )
log_debug("key %08lX: checking secret key\n", (ulong)keyid[1] );
if( is_secret_key_protected( sk ) < 1 )
log_info(_("NOTE: secret key %08lX is NOT protected.\n"),
(ulong)keyid[1] );
for( kl = trusted_key_list; kl; kl = kl->next ) {
if( kl->keyid[0] == keyid[0] && kl->keyid[1] == keyid[1] )
goto skip; /* already in trusted key table */
}
/* see whether we can access the public key of this secret key */
memset( pk, 0, sizeof *pk );
rc = get_pubkey( pk, keyid );
if( rc ) {
log_info(_("key %08lX: secret key without public key - skipped\n"),
(ulong)keyid[1] );
goto skip;
}
have_pk=1;
if( cmp_public_secret_key( pk, sk ) ) {
log_info(_("key %08lX: secret and public key don't match\n"),
(ulong)keyid[1] );
goto skip;
}
/* make sure that the pubkey is in the trustdb */
rc = query_trust_record( pk );
if( rc == -1 ) { /* put it into the trustdb */
rc = insert_trust_record( pk );
if( rc ) {
log_error(_("key %08lX: can't put it into the trustdb\n"),
(ulong)keyid[1] );
goto skip;
}
}
else if( rc ) {
log_error(_("key %08lX: query record failed\n"), (ulong)keyid[1] );
goto skip;
}
if( DBG_TRUST )
log_debug("key %08lX.%lu: stored into ultikey_table\n",
(ulong)keyid[1], pk->local_id );
if( ins_lid_table_item( ultikey_table, pk->local_id, 0 ) )
log_error(_("key %08lX: already in trusted key table\n"),
(ulong)keyid[1]);
else if( opt.verbose > 1 )
log_info(_("key %08lX: accepted as trusted key.\n"),
(ulong)keyid[1]);
skip:
release_secret_key_parts( sk );
if( have_pk )
release_public_key_parts( pk );
}
if( rc != -1 )
log_error(_("enumerate secret keys failed: %s\n"), g10_errstr(rc) );
else
rc = 0;
/* release the trusted keyid table */
{ struct keyid_list *kl2;
for( kl = trusted_key_list; kl; kl = kl2 ) {
kl2 = kl->next;
m_free( kl );
}
trusted_key_list = NULL;
}
enum_secret_keys( &enum_context, NULL, 0 ); /* free context */
free_secret_key( sk );
free_public_key( pk );
return rc;
}
static void
print_user_id( const char *text, u32 *keyid )
{
char *p;
size_t n;
p = get_user_id( keyid, &n );
if( *text ) {
fputs( text, stdout);
putchar(' ');
}
putchar('\"');
print_string( stdout, p, n, 0 );
putchar('\"');
putchar('\n');
m_free(p);
}
#if 0
static int
print_keyid( FILE *fp, ulong lid )
{
u32 ki[2];
if( keyid_from_lid( lid, ki ) )
return fprintf(fp, "????????.%lu", lid );
else
return fprintf(fp, "%08lX.%lu", (ulong)ki[1], lid );
}
static int
print_trust( FILE *fp, unsigned trust )
{
int c;
switch( trust ) {
case TRUST_UNKNOWN: c = 'o'; break;
case TRUST_EXPIRED: c = 'e'; break;
case TRUST_UNDEFINED: c = 'q'; break;
case TRUST_NEVER: c = 'n'; break;
case TRUST_MARGINAL: c = 'm'; break;
case TRUST_FULLY: c = 'f'; break;
case TRUST_ULTIMATE: c = 'u'; break;
default: fprintf(fp, "%02x", trust ); return 2;
}
putc(c, fp);
return 1;
}
#endif
static int
print_sigflags( FILE *fp, unsigned flags )
{
if( flags & SIGF_CHECKED ) {
fprintf(fp,"%c%c%c",
(flags & SIGF_VALID) ? 'V':'-',
(flags & SIGF_EXPIRED) ? 'E':'-',
(flags & SIGF_REVOKED) ? 'R':'-');
}
else if( flags & SIGF_NOPUBKEY)
fputs("?--", fp);
else
fputs("---", fp);
return 3;
}
/* (a non-recursive algorithm would be easier) */
static int
do_list_sigs( ulong root, ulong pk_lid, int depth,
LOCAL_ID_TABLE lids, unsigned *lineno )
{
SIGREC_CONTEXT sx;
int rc;
u32 keyid[2];
memset( &sx, 0, sizeof sx );
sx.lid = pk_lid;
for(;;) {
rc = walk_sigrecs( &sx ); /* should we replace it and use */
if( rc ) /* use a loop like in collect_paths ??*/
break;
rc = keyid_from_lid( sx.sig_lid, keyid );
if( rc ) {
printf("%6u: %*s????????.%lu:", *lineno, depth*4, "", sx.sig_lid );
print_sigflags( stdout, sx.sig_flag );
putchar('\n');
++*lineno;
}
else {
printf("%6u: %*s%08lX.%lu:", *lineno, depth*4, "",
(ulong)keyid[1], sx.sig_lid );
print_sigflags( stdout, sx.sig_flag );
putchar(' ');
/* check whether we already checked this pk_lid */
if( !qry_lid_table_flag( ultikey_table, sx.sig_lid, NULL ) ) {
print_user_id("[ultimately trusted]", keyid);
++*lineno;
}
else if( sx.sig_lid == pk_lid ) {
printf("[self-signature]\n");
++*lineno;
}
else if( sx.sig_lid == root ) {
printf("[closed]\n");
++*lineno;
}
else if( ins_lid_table_item( lids, sx.sig_lid, *lineno ) ) {
unsigned refline;
qry_lid_table_flag( lids, sx.sig_lid, &refline );
printf("[see line %u]\n", refline);
++*lineno;
}
else if( depth+1 >= MAX_LIST_SIGS_DEPTH ) {
print_user_id( "[too deeply nested]", keyid );
++*lineno;
}
else {
print_user_id( "", keyid );
++*lineno;
rc = do_list_sigs( root, sx.sig_lid, depth+1, lids, lineno );
if( rc )
break;
}
}
}
return rc==-1? 0 : rc;
}
/****************
* List all signatures of a public key
*/
static int
list_sigs( ulong pubkey_id )
{
int rc;
u32 keyid[2];
LOCAL_ID_TABLE lids;
unsigned lineno = 1;
rc = keyid_from_lid( pubkey_id, keyid );
if( rc )
return rc;
printf("Signatures of %08lX.%lu ", (ulong)keyid[1], pubkey_id );
print_user_id("", keyid);
printf("----------------------\n");
lids = new_lid_table();
rc = do_list_sigs( pubkey_id, pubkey_id, 0, lids, &lineno );
putchar('\n');
release_lid_table(lids);
return rc;
}
/****************
* List all records of a public key
*/
static int
list_records( ulong lid )
{
int rc;
TRUSTREC dr, ur, rec;
ulong recno;
rc = tdbio_read_record( lid, &dr, RECTYPE_DIR );
if( rc ) {
log_error(_("lid %lu: read dir record failed: %s\n"),
lid, g10_errstr(rc));
return rc;
}
tdbio_dump_record( &dr, stdout );
for( recno=dr.r.dir.keylist; recno; recno = rec.r.key.next ) {
rc = tdbio_read_record( recno, &rec, 0 );
if( rc ) {
log_error(_("lid %lu: read key record failed: %s\n"),
lid, g10_errstr(rc));
return rc;
}
tdbio_dump_record( &rec, stdout );
}
for( recno=dr.r.dir.uidlist; recno; recno = ur.r.uid.next ) {
rc = tdbio_read_record( recno, &ur, RECTYPE_UID );
if( rc ) {
log_error(_("lid %lu: read uid record failed: %s\n"),
lid, g10_errstr(rc));
return rc;
}
tdbio_dump_record( &ur, stdout );
/* preference records */
for(recno=ur.r.uid.prefrec; recno; recno = rec.r.pref.next ) {
rc = tdbio_read_record( recno, &rec, RECTYPE_PREF );
if( rc ) {
log_error(_("lid %lu: read pref record failed: %s\n"),
lid, g10_errstr(rc));
return rc;
}
tdbio_dump_record( &rec, stdout );
}
/* sig records */
for(recno=ur.r.uid.siglist; recno; recno = rec.r.sig.next ) {
rc = tdbio_read_record( recno, &rec, RECTYPE_SIG );
if( rc ) {
log_error(_("lid %lu: read sig record failed: %s\n"),
lid, g10_errstr(rc));
return rc;
}
tdbio_dump_record( &rec, stdout );
}
}
/* add cache record dump here */
return rc;
}
/****************
* stack is an array of (max_path+1) elements. If trust_seg_head is not
* NULL it is a pointer to a variable which will receive a linked list
* of trust paths - The caller has to free the memory.
*/
static int
collect_paths( int depth, int max_depth, int all, TRUSTREC *drec,
TRUST_INFO *stack, TRUST_SEG_LIST *trust_seg_head )
{
ulong rn, uidrn;
int marginal=0;
int fully=0;
LOCAL_ID_TABLE sigs_seen = NULL;
if( depth >= max_depth ) /* max cert_depth reached */
return TRUST_UNDEFINED;
stack[depth].lid = drec->r.dir.lid;
stack[depth].otrust = drec->r.dir.ownertrust;
stack[depth].trust = 0;
{ int i;
for(i=0; i < depth; i++ )
if( stack[i].lid == drec->r.dir.lid )
return TRUST_UNDEFINED; /* closed (we already visited this lid) */
}
if( !qry_lid_table_flag( ultikey_table, drec->r.dir.lid, NULL ) ) {
/* we are at the end of a path */
TRUST_SEG_LIST tsl;
int i;
stack[depth].trust = TRUST_ULTIMATE;
stack[depth].otrust = TRUST_ULTIMATE;
if( trust_seg_head ) {
/* we can now put copy our current stack to the trust_seg_list */
tsl = m_alloc( sizeof *tsl + (depth+1)*sizeof( TRUST_INFO ) );
for(i=0; i <= depth; i++ )
tsl->path[i] = stack[i];
tsl->pathlen = i;
tsl->next = *trust_seg_head;
*trust_seg_head = tsl;
}
return TRUST_ULTIMATE;
}
/* loop over all user-ids */
if( !all )
sigs_seen = new_lid_table();
for( rn = drec->r.dir.uidlist; rn; rn = uidrn ) {
TRUSTREC rec; /* used for uids and sigs */
ulong sigrn;
read_record( rn, &rec, RECTYPE_UID );
uidrn = rec.r.uid.next;
if( !(rec.r.uid.uidflags & UIDF_CHECKED) )
continue; /* user id has not been checked */
if( !(rec.r.uid.uidflags & UIDF_VALID) )
continue; /* user id is not valid */
if( (rec.r.uid.uidflags & UIDF_REVOKED) )
continue; /* user id has been revoked */
/* loop over all signature records */
for( rn = rec.r.uid.siglist; rn; rn = sigrn ) {
int i;
read_record( rn, &rec, RECTYPE_SIG );
sigrn = rec.r.sig.next;
for(i=0; i < SIGS_PER_RECORD; i++ ) {
TRUSTREC tmp;
int ot, nt;
+ int unchecked = 0;
if( !rec.r.sig.sig[i].lid )
continue; /* skip deleted sigs */
- if( !(rec.r.sig.sig[i].flag & SIGF_CHECKED) )
- continue; /* skip unchecked signatures */
- if( !(rec.r.sig.sig[i].flag & SIGF_VALID) )
- continue; /* skip invalid signatures */
- if( (rec.r.sig.sig[i].flag & SIGF_EXPIRED) )
- continue; /* skip expired signatures */
- if( (rec.r.sig.sig[i].flag & SIGF_REVOKED) )
- continue; /* skip revoked signatures */
+ if( !(rec.r.sig.sig[i].flag & SIGF_CHECKED) ) {
+ if( !all )
+ continue; /* skip unchecked signatures */
+ unchecked = 1;
+ }
+ else {
+ if( !(rec.r.sig.sig[i].flag & SIGF_VALID) )
+ continue; /* skip invalid signatures */
+ if( (rec.r.sig.sig[i].flag & SIGF_EXPIRED) )
+ continue; /* skip expired signatures */
+ if( (rec.r.sig.sig[i].flag & SIGF_REVOKED) )
+ continue; /* skip revoked signatures */
+ }
/* visit every signer only once (a signer may have
* signed more than one user ID) */
if( sigs_seen && ins_lid_table_item( sigs_seen,
rec.r.sig.sig[i].lid, 0) )
continue; /* we already have this one */
read_record( rec.r.sig.sig[i].lid, &tmp, 0 );
if( tmp.rectype != RECTYPE_DIR ) {
if( tmp.rectype != RECTYPE_SDIR )
log_info("oops: lid %lu: sig %lu has rectype %d"
" - skipped\n",
drec->r.dir.lid, tmp.recnum, tmp.rectype );
continue;
}
ot = tmp.r.dir.ownertrust & TRUST_MASK;
if( ot >= TRUST_FULLY )
ot = TRUST_FULLY; /* just in case */
nt = collect_paths( depth+1, max_depth, all, &tmp, stack,
trust_seg_head );
nt &= TRUST_MASK;
- if( nt < TRUST_MARGINAL ) {
+ if( nt < TRUST_MARGINAL || unchecked ) {
continue;
}
if( nt == TRUST_ULTIMATE ) {
/* we have signed this key and only in this special case
* we assume that this one is fully trusted */
if( !all ) {
if( sigs_seen )
release_lid_table( sigs_seen );
return (stack[depth].trust = TRUST_FULLY);
}
}
if( nt > ot )
nt = ot;
if( nt >= TRUST_FULLY )
fully++;
if( nt >= TRUST_MARGINAL )
marginal++;
if( fully >= opt.completes_needed
|| marginal >= opt.marginals_needed ) {
if( !all ) {
if( sigs_seen )
release_lid_table( sigs_seen );
return (stack[depth].trust = TRUST_FULLY);
}
}
}
}
}
if( sigs_seen )
release_lid_table( sigs_seen );
if( all && ( fully >= opt.completes_needed
|| marginal >= opt.marginals_needed ) ) {
return (stack[depth].trust = TRUST_FULLY );
}
if( marginal ) {
return (stack[depth].trust = TRUST_MARGINAL);
}
return (stack[depth].trust=TRUST_UNDEFINED);
}
/****************
* Given the directory record of a key, check whether we can
* find a path to an ultimately trusted key. We do this by
* checking all key signatures up to a some depth.
*/
static int
verify_key( int max_depth, TRUSTREC *drec )
{
TRUST_INFO *tmppath = m_alloc_clear( (max_depth+1)* sizeof *tmppath );
int tr;
tr = collect_paths( 0, max_depth, 0, drec, tmppath, NULL );
m_free( tmppath );
return tr;
}
/****************
* we have the pubkey record and all needed informations are in the trustdb
* but nothing more is known.
*/
static int
do_check( TRUSTREC *dr, unsigned *validity )
{
if( !dr->r.dir.keylist ) {
log_error(_("Ooops, no keys\n"));
return G10ERR_TRUSTDB;
}
if( !dr->r.dir.uidlist ) {
log_error(_("Ooops, no user ids\n"));
return G10ERR_TRUSTDB;
}
if( tdbio_db_matches_options()
&& (dr->r.dir.dirflags & DIRF_VALVALID)
&& dr->r.dir.validity )
*validity = dr->r.dir.validity;
else {
*validity = verify_key( opt.max_cert_depth, dr );
if( (*validity & TRUST_MASK) >= TRUST_UNDEFINED
&& tdbio_db_matches_options() ) {
/* update the cached validity value */
dr->r.dir.validity = (*validity & TRUST_MASK);
dr->r.dir.dirflags |= DIRF_VALVALID;
write_record( dr );
}
}
if( dr->r.dir.dirflags & DIRF_REVOKED )
*validity |= TRUST_FLAG_REVOKED;
return 0;
}
/****************
* Perform some checks over the trustdb
* level 0: only open the db
* 1: used for initial program startup
*/
int
init_trustdb( int level, const char *dbname )
{
int rc=0;
if( !ultikey_table )
ultikey_table = new_lid_table();
if( !level || level==1 ) {
rc = tdbio_set_dbname( dbname, !!level );
if( rc )
return rc;
if( !level )
return 0;
/* verify that our own keys are in the trustDB
* or move them to the trustdb. */
rc = verify_own_keys();
/* should we check whether there is no other ultimately trusted
* key in the database? */
}
else
BUG();
return rc;
}
void
list_trustdb( const char *username )
{
TRUSTREC rec;
if( username && *username == '#' ) {
int rc;
ulong lid = atoi(username+1);
if( (rc = list_records( lid)) )
log_error(_("user '%s' read problem: %s\n"),
username, g10_errstr(rc));
else if( (rc = list_sigs( lid )) )
log_error(_("user '%s' list problem: %s\n"),
username, g10_errstr(rc));
}
else if( username ) {
PKT_public_key *pk = m_alloc_clear( sizeof *pk );
int rc;
if( (rc = get_pubkey_byname( NULL, pk, username, NULL )) )
log_error(_("user '%s' not found: %s\n"), username, g10_errstr(rc) );
else if( (rc=tdbio_search_dir_bypk( pk, &rec )) && rc != -1 )
log_error(_("problem finding '%s' in trustdb: %s\n"),
username, g10_errstr(rc));
else if( rc == -1 )
log_error(_("user '%s' not in trustdb\n"), username);
else if( (rc = list_records( pk->local_id)) )
log_error(_("user '%s' read problem: %s\n"),
username, g10_errstr(rc));
else if( (rc = list_sigs( pk->local_id )) )
log_error(_("user '%s' list problem: %s\n"),
username, g10_errstr(rc));
free_public_key( pk );
}
else {
ulong recnum;
int i;
printf("TrustDB: %s\n", tdbio_get_dbname() );
for(i=9+strlen(tdbio_get_dbname()); i > 0; i-- )
putchar('-');
putchar('\n');
for(recnum=0; !tdbio_read_record( recnum, &rec, 0); recnum++ )
tdbio_dump_record( &rec, stdout );
}
}
/****************
* Print a list of all defined owner trust value.
*/
void
export_ownertrust()
{
TRUSTREC rec;
TRUSTREC rec2;
ulong recnum;
int i;
byte *p;
int rc;
printf(_("# List of assigned trustvalues, created %s\n"
"# (Use \"gpgm --import-ownertrust\" to restore them)\n"),
asctimestamp( make_timestamp() ) );
for(recnum=0; !tdbio_read_record( recnum, &rec, 0); recnum++ ) {
if( rec.rectype == RECTYPE_DIR ) {
if( !rec.r.dir.keylist ) {
log_error(_("directory record w/o primary key\n"));
continue;
}
if( !rec.r.dir.ownertrust )
continue;
rc = tdbio_read_record( rec.r.dir.keylist, &rec2, RECTYPE_KEY);
if( rc ) {
log_error(_("error reading key record: %s\n"), g10_errstr(rc));
continue;
}
p = rec2.r.key.fingerprint;
for(i=0; i < rec2.r.key.fingerprint_len; i++, p++ )
printf("%02X", *p );
printf(":%u:\n", (unsigned)rec.r.dir.ownertrust );
}
}
}
void
import_ownertrust( const char *fname )
{
FILE *fp;
int is_stdin=0;
char line[256];
char *p;
size_t n, fprlen;
unsigned otrust;
if( !fname || (*fname == '-' && !fname[1]) ) {
fp = stdin;
fname = "[stdin]";
is_stdin = 1;
}
else if( !(fp = fopen( fname, "r" )) ) {
log_error_f(fname, _("can't open file: %s\n"), strerror(errno) );
return;
}
while( fgets( line, DIM(line)-1, fp ) ) {
TRUSTREC rec;
int rc;
if( !*line || *line == '#' )
continue;
n = strlen(line);
if( line[n-1] != '\n' ) {
- log_error_f(fname, _("line to long\n") );
+ log_error_f(fname, _("line too long\n") );
/* ... or last line does not have a LF */
break; /* can't continue */
}
for(p = line; *p && *p != ':' ; p++ )
if( !isxdigit(*p) )
break;
if( *p != ':' ) {
log_error_f(fname, _("error: missing colon\n") );
continue;
}
fprlen = p - line;
if( fprlen != 32 && fprlen != 40 ) {
log_error_f(fname, _("error: invalid fingerprint\n") );
continue;
}
if( sscanf(p, ":%u:", &otrust ) != 1 ) {
log_error_f(fname, _("error: no ownertrust value\n") );
continue;
}
if( !otrust )
continue; /* no otrust defined - no need to update or insert */
/* convert the ascii fingerprint to binary */
for(p=line, fprlen=0; *p != ':'; p += 2 )
line[fprlen++] = HEXTOBIN(p[0]) * 16 + HEXTOBIN(p[1]);
line[fprlen] = 0;
repeat:
rc = tdbio_search_dir_byfpr( line, fprlen, 0, &rec );
if( !rc ) { /* found: update */
if( rec.r.dir.ownertrust )
log_info(_("LID %lu: changing trust from %u to %u\n"),
rec.r.dir.lid, rec.r.dir.ownertrust, otrust );
else
log_info(_("LID %lu: setting trust to %u\n"),
rec.r.dir.lid, otrust );
rec.r.dir.ownertrust = otrust;
write_record( &rec );
}
else if( rc == -1 ) { /* not found; get the key from the ring */
PKT_public_key *pk = m_alloc_clear( sizeof *pk );
log_info_f(fname, _("key not in trustdb, searching ring.\n"));
rc = get_pubkey_byfprint( pk, line, fprlen );
if( rc )
log_info_f(fname, _("key not in ring: %s\n"), g10_errstr(rc));
else {
rc = query_trust_record( pk ); /* only as assertion */
if( rc != -1 )
log_error_f(fname, _("Oops: key is now in trustdb???\n"));
else {
rc = insert_trust_record( pk );
if( !rc )
goto repeat; /* update the ownertrust */
log_error_f(fname, _("insert trust record failed: %s\n"),
g10_errstr(rc) );
}
}
}
else /* error */
log_error_f(fname, _("error finding dir record: %s\n"),
g10_errstr(rc));
}
if( ferror(fp) )
log_error_f(fname, _("read error: %s\n"), strerror(errno) );
if( !is_stdin )
fclose(fp);
do_sync();
}
static void
-print_path( int pathlen, TRUST_INFO *path )
+print_path( int pathlen, TRUST_INFO *path, FILE *fp, ulong highlight )
{
int rc, c, i;
u32 keyid[2];
char *p;
size_t n;
for( i = 0; i < pathlen; i++ ) {
- printf("%*s", i*2, "" );
+ if( highlight )
+ fputs(highlight == path[i].lid? "* ":" ", fp );
rc = keyid_from_lid( path[i].lid, keyid );
if( rc )
- printf("????????.%lu:", path[i].lid );
+ fprintf(fp, "????????.%lu:", path[i].lid );
else
- printf("%08lX.%lu:", (ulong)keyid[1], path[i].lid );
+ fprintf(fp,"%08lX.%lu:", (ulong)keyid[1], path[i].lid );
c = trust_letter(path[i].otrust);
if( c )
- putchar( c );
+ putc( c, fp );
else
- printf( "%02x", path[i].otrust );
- putchar('/');
+ fprintf( fp, "%02x", path[i].otrust );
+ putc('/', fp);
c = trust_letter(path[i].trust);
if( c )
- putchar( c );
+ putc( c, fp );
else
- printf( "%02x", path[i].trust );
- putchar(' ');
+ fprintf( fp, "%02x", path[i].trust );
+ putc(' ', fp);
p = get_user_id( keyid, &n );
- putchar(' ');
- putchar('\"');
- print_string( stdout, p, n > 40? 40:n, 0 );
- putchar('\"');
+ putc(' ', fp);
+ putc('\"', fp);
+ print_string( fp, p, n > 40? 40:n, 0 );
+ putc('\"', fp);
m_free(p);
- putchar('\n');
+ putc('\n', fp );
}
}
+static int
+cmp_tsl_array( const void *xa, const void *xb )
+{
+ TRUST_SEG_LIST a = *(TRUST_SEG_LIST*)xa;
+ TRUST_SEG_LIST b = *(TRUST_SEG_LIST*)xb;
+ return a->pathlen - b->pathlen;
+}
+
+
+static void
+sort_tsl_list( TRUST_SEG_LIST *trust_seg_list )
+{
+ TRUST_SEG_LIST *array, *tail, tsl;
+ size_t n;
+
+ for(n=0, tsl = *trust_seg_list; tsl; tsl = tsl->next )
+ n++;
+ array = m_alloc( (n+1) * sizeof *array );
+ for(n=0, tsl = *trust_seg_list; tsl; tsl = tsl->next )
+ array[n++] = tsl;
+ array[n] = NULL;
+ qsort( array, n, sizeof *array, cmp_tsl_array );
+ *trust_seg_list = NULL;
+ tail = trust_seg_list;
+ for(n=0; (tsl=array[n]); n++ ) {
+ *tail = tsl;
+ tail = &tsl->next;
+ }
+ m_free( array );
+}
+
void
list_trust_path( const char *username )
{
int rc;
TRUSTREC rec;
TRUST_INFO *tmppath;
TRUST_SEG_LIST trust_seg_list, tsl, tsl2;
PKT_public_key *pk = m_alloc_clear( sizeof *pk );
if( (rc = get_pubkey_byname(NULL, pk, username, NULL )) )
log_error(_("user '%s' not found: %s\n"), username, g10_errstr(rc) );
else if( (rc=tdbio_search_dir_bypk( pk, &rec )) && rc != -1 )
log_error(_("problem finding '%s' in trustdb: %s\n"),
username, g10_errstr(rc));
else if( rc == -1 ) {
log_info(_("user '%s' not in trustdb - inserting\n"), username);
rc = insert_trust_record( pk );
if( rc )
log_error(_("failed to put '%s' into trustdb: %s\n"),
username, g10_errstr(rc));
else {
assert( pk->local_id );
}
}
free_public_key( pk );
/* collect the paths */
tmppath = m_alloc_clear( (opt.max_cert_depth+1)* sizeof *tmppath );
trust_seg_list = NULL;
collect_paths( 0, opt.max_cert_depth, 1, &rec, tmppath, &trust_seg_list );
m_free( tmppath );
+ sort_tsl_list( &trust_seg_list );
/* and now print them */
for(tsl = trust_seg_list; tsl; tsl = tsl->next ) {
- print_path( tsl->pathlen, tsl->path );
+ print_path( tsl->pathlen, tsl->path, stdout, 0 );
+ if( tsl->next )
+ putchar('\n');
}
/* release the list */
for(tsl = trust_seg_list; tsl; tsl = tsl2 ) {
tsl2 = tsl->next;
m_free( tsl );
}
trust_seg_list = NULL;
}
/****************
* Check the complete trustdb or only the entries for the given username.
* We check the complete database. If a username is given or the special
* username "*" is used, a complete recheck is done. With no user ID
* only the records which are not yet checkd are now checked.
*/
void
check_trustdb( const char *username )
{
TRUSTREC rec;
KBNODE keyblock = NULL;
KBPOS kbpos;
int rc;
int recheck = username && *username == '*' && !username[1];
if( username && !recheck ) {
rc = find_keyblock_byname( &kbpos, username );
if( !rc )
rc = read_keyblock( &kbpos, &keyblock );
if( rc ) {
log_error(_("%s: keyblock read problem: %s\n"),
username, g10_errstr(rc));
}
else {
int modified;
rc = update_trust_record( keyblock, 1, &modified );
if( rc == -1 ) { /* not yet in trustdb: insert */
rc = insert_trust_record(
find_kbnode( keyblock, PKT_PUBLIC_KEY
) ->pkt->pkt.public_key );
}
if( rc )
log_error(_("%s: update failed: %s\n"),
username, g10_errstr(rc) );
else if( modified )
log_info(_("%s: updated\n"), username );
else
log_info(_("%s: okay\n"), username );
}
release_kbnode( keyblock ); keyblock = NULL;
}
else {
ulong recnum;
ulong count=0, upd_count=0, err_count=0, skip_count=0;
for(recnum=0; !tdbio_read_record( recnum, &rec, 0); recnum++ ) {
if( rec.rectype == RECTYPE_DIR ) {
TRUSTREC tmp;
int modified;
if( !rec.r.dir.keylist ) {
log_info(_("lid %lu: dir record w/o key - skipped\n"),
recnum);
count++;
skip_count++;
continue;
}
read_record( rec.r.dir.keylist, &tmp, RECTYPE_KEY );
rc = get_keyblock_byfprint( &keyblock,
tmp.r.key.fingerprint,
tmp.r.key.fingerprint_len );
if( rc ) {
log_error(_("lid %lu: keyblock not found: %s\n"),
recnum, g10_errstr(rc) );
count++;
skip_count++;
continue;
}
rc = update_trust_record( keyblock, recheck, &modified );
if( rc ) {
log_error(_("lid %lu: update failed: %s\n"),
recnum, g10_errstr(rc) );
err_count++;
}
else if( modified ) {
if( opt.verbose )
log_info(_("lid %lu: updated\n"), recnum );
upd_count++;
}
else if( opt.verbose > 1 )
log_info(_("lid %lu: okay\n"), recnum );
release_kbnode( keyblock ); keyblock = NULL;
if( !(++count % 100) )
log_info(_("%lu keys so far processed\n"), count);
}
}
log_info(_("%lu keys processed\n"), count);
if( skip_count )
log_info(_("\t%lu keys skipped\n"), skip_count);
if( err_count )
log_info(_("\t%lu keys with errors\n"), err_count);
if( upd_count )
log_info(_("\t%lu keys updated\n"), upd_count);
}
}
/****************
* Put new entries from the pubrings into the trustdb.
* This function honors the sig flags to speed up the check.
*/
void
update_trustdb( )
{
KBNODE keyblock = NULL;
KBPOS kbpos;
int rc;
rc = enum_keyblocks( 0, &kbpos, &keyblock );
if( !rc ) {
ulong count=0, upd_count=0, err_count=0, new_count=0;
while( !(rc = enum_keyblocks( 1, &kbpos, &keyblock )) ) {
int modified;
rc = update_trust_record( keyblock, 1, &modified );
if( rc == -1 ) { /* not yet in trustdb: insert */
PKT_public_key *pk =
find_kbnode( keyblock, PKT_PUBLIC_KEY
) ->pkt->pkt.public_key;
rc = insert_trust_record( pk );
if( rc && !pk->local_id ) {
log_error(_("lid ?: insert failed: %s\n"),
g10_errstr(rc) );
err_count++;
}
else if( rc ) {
log_error(_("lid %lu: insert failed: %s\n"),
pk->local_id, g10_errstr(rc) );
err_count++;
}
else {
if( opt.verbose )
log_info(_("lid %lu: inserted\n"), pk->local_id );
new_count++;
}
}
else if( rc ) {
log_error(_("lid %lu: update failed: %s\n"),
lid_from_keyblock(keyblock), g10_errstr(rc) );
err_count++;
}
else if( modified ) {
if( opt.verbose )
log_info(_("lid %lu: updated\n"), lid_from_keyblock(keyblock));
upd_count++;
}
else if( opt.verbose > 1 )
log_info(_("lid %lu: okay\n"), lid_from_keyblock(keyblock) );
release_kbnode( keyblock ); keyblock = NULL;
if( !(++count % 100) )
log_info(_("%lu keys so far processed\n"), count);
}
log_info(_("%lu keys processed\n"), count);
if( err_count )
log_info(_("\t%lu keys with errors\n"), err_count);
if( upd_count )
log_info(_("\t%lu keys updated\n"), upd_count);
if( new_count )
log_info(_("\t%lu keys inserted\n"), new_count);
}
if( rc && rc != -1 )
log_error(_("enumerate keyblocks failed: %s\n"), g10_errstr(rc));
enum_keyblocks( 2, &kbpos, &keyblock ); /* close */
release_kbnode( keyblock );
}
/****************
* Get the trustlevel for this PK.
* Note: This does not ask any questions
* Returns: 0 okay of an errorcode
*
* It operates this way:
* locate the pk in the trustdb
* found:
* Do we have a valid cache record for it?
* yes: return trustlevel from cache
* no: make a cache record and all the other stuff
* not found:
* try to insert the pubkey into the trustdb and check again
*
* Problems: How do we get the complete keyblock to check that the
* cache record is actually valid? Think we need a clever
* cache in getkey.c to keep track of this stuff. Maybe it
* is not necessary to check this if we use a local pubring. Hmmmm.
*/
int
check_trust( PKT_public_key *pk, unsigned *r_trustlevel )
{
TRUSTREC rec;
unsigned trustlevel = TRUST_UNKNOWN;
int rc=0;
u32 cur_time;
u32 keyid[2];
keyid_from_pk( pk, keyid );
/* get the pubkey record */
if( pk->local_id ) {
read_record( pk->local_id, &rec, RECTYPE_DIR );
}
else { /* no local_id: scan the trustdb */
if( (rc=tdbio_search_dir_bypk( pk, &rec )) && rc != -1 ) {
log_error(_("check_trust: search dir record failed: %s\n"),
g10_errstr(rc));
return rc;
}
else if( rc == -1 ) { /* not found - insert */
rc = insert_trust_record( pk );
if( rc ) {
log_error(_("key %08lX: insert trust record failed: %s\n"),
(ulong)keyid[1], g10_errstr(rc));
goto leave;
}
log_info(_("key %08lX.%lu: inserted into trustdb\n"),
(ulong)keyid[1], pk->local_id );
/* and re-read the dir record */
read_record( pk->local_id, &rec, RECTYPE_DIR );
}
}
cur_time = make_timestamp();
if( pk->timestamp > cur_time ) {
log_info(_("key %08lX.%lu: created in future "
"(time warp or clock problem)\n"),
(ulong)keyid[1], pk->local_id );
return G10ERR_TIME_CONFLICT;
}
if( pk->expiredate && pk->expiredate <= cur_time ) {
log_info(_("key %08lX.%lu: expired at %s\n"),
(ulong)keyid[1], pk->local_id,
asctimestamp( pk->expiredate) );
trustlevel = TRUST_EXPIRED;
}
else {
rc = do_check( &rec, &trustlevel );
if( rc ) {
log_error(_("key %08lX.%lu: trust check failed: %s\n"),
(ulong)keyid[1], pk->local_id, g10_errstr(rc));
return rc;
}
}
leave:
if( DBG_TRUST )
log_debug("check_trust() returns trustlevel %04x.\n", trustlevel);
*r_trustlevel = trustlevel;
return 0;
}
int
query_trust_info( PKT_public_key *pk )
{
unsigned trustlevel;
int c;
if( check_trust( pk, &trustlevel ) )
return '?';
if( trustlevel & TRUST_FLAG_REVOKED )
return 'r';
c = trust_letter( (trustlevel & TRUST_MASK) );
if( !c )
c = '?';
return c;
}
/****************
* Enumerate all keys, which are needed to build all trust paths for
* the given key. This function does not return the key itself or
* the ultimate key (the last point in cerificate chain). Only
* certificate chains which ends up at an ultimately trusted key
* are listed. If ownertrust or validity is not NULL, the corresponding
* value for the returned LID is also returned in these variable(s).
*
* 1) create a void pointer and initialize it to NULL
* 2) pass this void pointer by reference to this function.
* Set lid to the key you want to enumerate and pass it by reference.
* 3) call this function as long as it does not return -1
* to indicate EOF. LID does contain the next key used to build the web
* 4) Always call this function a last time with LID set to NULL,
* so that it can free its context.
*
* Returns: -1 on EOF or the level of the returned LID
*/
int
enum_cert_paths( void **context, ulong *lid,
unsigned *ownertrust, unsigned *validity )
{
- struct {
- int init;
- TRUST_SEG_LIST tsl_head;
- TRUST_SEG_LIST tsl;
- int idx;
- } *ctx;
+ struct enum_cert_paths_ctx *ctx;
TRUST_SEG_LIST tsl;
if( !lid ) { /* release the context */
if( *context ) {
TRUST_SEG_LIST tsl2;
ctx = *context;
for(tsl = ctx->tsl_head; tsl; tsl = tsl2 ) {
tsl2 = tsl->next;
m_free( tsl );
}
*context = NULL;
}
return -1;
}
if( !*context ) {
TRUST_INFO *tmppath;
TRUSTREC rec;
if( !*lid )
return -1;
ctx = m_alloc_clear( sizeof *ctx );
*context = ctx;
/* collect the paths */
read_record( *lid, &rec, RECTYPE_DIR );
tmppath = m_alloc_clear( (opt.max_cert_depth+1)* sizeof *tmppath );
tsl = NULL;
collect_paths( 0, opt.max_cert_depth, 1, &rec, tmppath, &tsl );
m_free( tmppath );
- /* and now print them */
+ sort_tsl_list( &tsl );
+ /* setup the context */
ctx->tsl_head = tsl;
ctx->tsl = ctx->tsl_head;
ctx->idx = 0;
}
else
ctx = *context;
while( ctx->tsl && ctx->idx >= ctx->tsl->pathlen ) {
ctx->tsl = ctx->tsl->next;
ctx->idx = 0;
}
tsl = ctx->tsl;
if( !tsl )
return -1; /* eof */
if( ownertrust )
*ownertrust = tsl->path[ctx->idx].otrust;
if( validity )
*validity = tsl->path[ctx->idx].trust;
*lid = tsl->path[ctx->idx].lid;
ctx->idx++;
return ctx->idx-1;
}
+/****************
+ * Print the current path
+ */
+int
+enum_cert_paths_print( void **context, FILE *fp, ulong selected_lid )
+{
+ struct enum_cert_paths_ctx *ctx;
+ TRUST_SEG_LIST tsl;
+
+ if( !*context )
+ return;
+ ctx = *context;
+ if( !ctx->tsl )
+ return;
+
+ if( !fp )
+ fp = stderr;
+
+ print_path( ctx->tsl->pathlen, ctx->tsl->path, fp, selected_lid );
+}
+
+
/****************
* Return the assigned ownertrust value for the given LID
*/
unsigned
get_ownertrust( ulong lid )
{
TRUSTREC rec;
read_record( lid, &rec, RECTYPE_DIR );
return rec.r.dir.ownertrust;
}
int
get_ownertrust_info( ulong lid )
{
unsigned otrust;
int c;
otrust = get_ownertrust( lid );
c = trust_letter( (otrust & TRUST_MASK) );
if( !c )
c = '?';
return c;
}
/*
* Return an allocated buffer with the preference values for
* the key with LID and the userid which is identified by the
* HAMEHASH or the firstone if namehash is NULL. ret_n receives
* the length of the allcoated buffer. Structure of the buffer is
* a repeated sequences of 2 bytes; where the first byte describes the
* type of the preference and the second one the value. The constants
* PREFTYPE_xxxx should be used to reference a type.
*/
byte *
get_pref_data( ulong lid, const byte *namehash, size_t *ret_n )
{
TRUSTREC rec;
ulong recno;
read_record( lid, &rec, RECTYPE_DIR );
for( recno=rec.r.dir.uidlist; recno; recno = rec.r.uid.next ) {
read_record( recno, &rec, RECTYPE_UID );
if( rec.r.uid.prefrec
&& ( !namehash || !memcmp(namehash, rec.r.uid.namehash, 20) )) {
byte *buf;
/* found the correct one or the first one */
read_record( rec.r.uid.prefrec, &rec, RECTYPE_PREF );
if( rec.r.pref.next )
log_info(_("WARNING: can't yet handle long pref records\n"));
buf = m_alloc( ITEMS_PER_PREF_RECORD );
memcpy( buf, rec.r.pref.data, ITEMS_PER_PREF_RECORD );
*ret_n = ITEMS_PER_PREF_RECORD;
return buf;
}
}
return NULL;
}
/****************
* Check whether the algorithm is in one of the pref records
*/
int
is_algo_in_prefs( ulong lid, int preftype, int algo )
{
TRUSTREC rec;
ulong recno;
int i;
byte *pref;
read_record( lid, &rec, RECTYPE_DIR );
for( recno=rec.r.dir.uidlist; recno; recno = rec.r.uid.next ) {
read_record( recno, &rec, RECTYPE_UID );
if( rec.r.uid.prefrec ) {
read_record( rec.r.uid.prefrec, &rec, RECTYPE_PREF );
if( rec.r.pref.next )
log_info(_("WARNING: can't yet handle long pref records\n"));
pref = rec.r.pref.data;
for(i=0; i+1 < ITEMS_PER_PREF_RECORD; i+=2 ) {
if( pref[i] == preftype && pref[i+1] == algo )
return 1;
}
}
}
return 0;
}
static int
get_dir_record( PKT_public_key *pk, TRUSTREC *rec )
{
int rc=0;
if( pk->local_id ) {
read_record( pk->local_id, rec, RECTYPE_DIR );
}
else { /* no local_id: scan the trustdb */
if( (rc=tdbio_search_dir_bypk( pk, rec )) && rc != -1 )
log_error(_("get_dir_record: search_record failed: %s\n"),
g10_errstr(rc));
}
return rc;
}
/****************
* This function simply looks for the key in the trustdb
* and makes sure that pk->local_id is set to the correct value.
* Return: 0 = found
* -1 = not found
* other = error
*/
int
query_trust_record( PKT_public_key *pk )
{
TRUSTREC rec;
return get_dir_record( pk, &rec );
}
int
clear_trust_checked_flag( PKT_public_key *pk )
{
TRUSTREC rec;
int rc;
rc = get_dir_record( pk, &rec );
if( rc )
return rc;
/* check whether they are already reset */
if( !(rec.r.dir.dirflags & DIRF_CHECKED)
&& !(rec.r.dir.dirflags & DIRF_VALVALID) )
return 0;
/* reset the flag */
rec.r.dir.dirflags &= ~DIRF_CHECKED;
rec.r.dir.dirflags &= ~DIRF_VALVALID;
write_record( &rec );
do_sync();
return 0;
}
static void
check_hint_sig( ulong lid, KBNODE keyblock, u32 *keyid, byte *uidrec_hash,
TRUSTREC *sigrec, int sigidx, ulong hint_owner )
{
KBNODE node;
int rc, state;
byte uhash[20];
int is_selfsig;
PKT_signature *sigpkt = NULL;
TRUSTREC tmp;
u32 sigkid[2];
int revoke = 0;
if( sigrec->r.sig.sig[sigidx].flag & SIGF_CHECKED )
log_info(_("NOTE: sig rec %lu[%d] in hintlist "
"of %lu but marked as checked\n"),
sigrec->recnum, sigidx, hint_owner );
if( !(sigrec->r.sig.sig[sigidx].flag & SIGF_NOPUBKEY) )
log_info(_("NOTE: sig rec %lu[%d] in hintlist "
"of %lu but not marked\n"),
sigrec->recnum, sigidx, hint_owner );
read_record( sigrec->r.sig.sig[sigidx].lid, &tmp, 0 );
if( tmp.rectype != RECTYPE_DIR ) {
/* we need the dir record */
log_error(_("sig rec %lu[%d] in hintlist "
"of %lu does not point to a dir record\n"),
sigrec->recnum, sigidx, hint_owner );
return;
}
if( !tmp.r.dir.keylist ) {
log_error(_("lid %lu: no primary key\n"), tmp.r.dir.lid );
return;
}
read_record(tmp.r.dir.keylist, &tmp, RECTYPE_KEY );
keyid_from_fingerprint( tmp.r.key.fingerprint,
tmp.r.key.fingerprint_len, sigkid );
/* find the correct signature packet */
state = 0;
for( node=keyblock; node; node = node->next ) {
if( node->pkt->pkttype == PKT_USER_ID ) {
PKT_user_id *uidpkt = node->pkt->pkt.user_id;
if( state )
break;
rmd160_hash_buffer( uhash, uidpkt->name, uidpkt->len );
if( !memcmp( uhash, uidrec_hash, 20 ) )
state = 1;
}
else if( state && node->pkt->pkttype == PKT_SIGNATURE ) {
sigpkt = node->pkt->pkt.signature;
if( sigpkt->keyid[0] == sigkid[0]
&& sigpkt->keyid[1] == sigkid[1]
&& ( (sigpkt->sig_class&~3) == 0x10
|| ( revoke = (sigpkt->sig_class == 0x30)) ) ) {
state = 2;
break; /* found */
}
}
}
if( !node ) {
log_info(_("lid %lu: user id not found in keyblock\n"), lid );
return ;
}
if( state != 2 ) {
log_info(_("lid %lu: user id without signature\n"), lid );
return ;
}
/* and check the sig */
rc = check_key_signature( keyblock, node, &is_selfsig );
if( is_selfsig ) {
log_error(_("lid %lu: self-signature in hintlist\n"), lid );
return;
}
/* FiXME: handling fo SIGF_REVOKED is not correct! */
if( !rc ) { /* valid signature */
if( opt.verbose )
log_info("sig %08lX.%lu/%02X%02X/%08lX: %s\n",
(ulong)keyid[1], lid, uhash[18], uhash[19],
(ulong)sigpkt->keyid[1],
revoke? _("Valid certificate revocation")
: _("Good certificate") );
sigrec->r.sig.sig[sigidx].flag = SIGF_CHECKED | SIGF_VALID;
if( revoke )
sigrec->r.sig.sig[sigidx].flag |= SIGF_REVOKED;
}
else if( rc == G10ERR_NO_PUBKEY ) {
log_info("sig %08lX.%lu/%02X%02X/%08lX: %s\n",
(ulong)keyid[1], lid, uhash[18], uhash[19],
(ulong)sigpkt->keyid[1],
_("very strange: no public key\n") );
sigrec->r.sig.sig[sigidx].flag = SIGF_NOPUBKEY;
}
else {
log_info("sig %08lX.%lu/%02X%02X/%08lX: %s\n",
(ulong)keyid[1], lid, uhash[18], uhash[19],
(ulong)sigpkt->keyid[1], g10_errstr(rc) );
sigrec->r.sig.sig[sigidx].flag = SIGF_CHECKED;
}
sigrec->dirty = 1;
}
/****************
* Process a hintlist.
* Fixme: this list is not anymore anchored to another
* record, so it should be put elsewehere in case of an error
*/
static void
process_hintlist( ulong hintlist, ulong hint_owner )
{
ulong hlst_rn;
int rc;
for( hlst_rn = hintlist; hlst_rn; ) {
TRUSTREC hlstrec;
int hlst_idx;
read_record( hlst_rn, &hlstrec, RECTYPE_HLST );
for( hlst_idx=0; hlst_idx < ITEMS_PER_HLST_RECORD; hlst_idx++ ) {
TRUSTREC dirrec;
TRUSTREC uidrec;
TRUSTREC tmprec;
KBNODE keyblock = NULL;
u32 keyid[2];
ulong lid;
ulong r1, r2;
lid = hlstrec.r.hlst.rnum[hlst_idx];
if( !lid )
continue;
read_record( lid, &dirrec, 0 );
/* make sure it points to a dir record:
* this should be true because it only makes sense to
* call this function if the dir record is available */
if( dirrec.rectype != RECTYPE_DIR ) {
log_error(_("hintlist %lu[%d] of %lu "
"does not point to a dir record\n"),
hlst_rn, hlst_idx, hint_owner );
continue;
}
if( !dirrec.r.dir.keylist ) {
log_error(_("lid %lu does not have a key\n"), lid );
continue;
}
/* get the keyblock */
read_record( dirrec.r.dir.keylist, &tmprec, RECTYPE_KEY );
rc = get_keyblock_byfprint( &keyblock,
tmprec.r.key.fingerprint,
tmprec.r.key.fingerprint_len );
if( rc ) {
log_error(_("lid %lu: can't get keyblock: %s\n"),
lid, g10_errstr(rc) );
continue;
}
keyid_from_fingerprint( tmprec.r.key.fingerprint,
tmprec.r.key.fingerprint_len, keyid );
/* Walk over all user ids and their signatures and check all
* the signature which are created by hint_owner */
for( r1 = dirrec.r.dir.uidlist; r1; r1 = uidrec.r.uid.next ) {
TRUSTREC sigrec;
read_record( r1, &uidrec, RECTYPE_UID );
for( r2 = uidrec.r.uid.siglist; r2; r2 = sigrec.r.sig.next ) {
int i;
read_record( r2, &sigrec, RECTYPE_SIG );
sigrec.dirty = 0;
for(i=0; i < SIGS_PER_RECORD; i++ ) {
if( !sigrec.r.sig.sig[i].lid )
continue; /* skip deleted sigs */
if( sigrec.r.sig.sig[i].lid != hint_owner )
continue; /* not for us */
/* some diagnostic messages */
/* and do the signature check */
check_hint_sig( lid, keyblock, keyid,
uidrec.r.uid.namehash,
&sigrec, i, hint_owner );
}
if( sigrec.dirty )
write_record( &sigrec );
}
}
release_kbnode( keyblock );
} /* loop over hlst entries */
/* delete this hlst record */
hlst_rn = hlstrec.r.hlst.next;
delete_record( hlstrec.recnum );
} /* loop over hintlist */
}
/****************
* Create or update shadow dir record and return the LID of the record
*/
static ulong
create_shadow_dir( PKT_signature *sig, ulong lid )
{
TRUSTREC sdir, hlst, tmphlst;
ulong recno, newlid;
int tmpidx=0; /* avoids gcc warnign - this is controlled by tmphlst */
int rc;
/* first see whether we already have such a record */
rc = tdbio_search_sdir( sig->keyid, sig->pubkey_algo, &sdir );
if( rc && rc != -1 ) {
log_error(_("tdbio_search_dir failed: %s\n"), g10_errstr(rc));
die_invalid_db();
}
if( rc == -1 ) { /* not found: create */
memset( &sdir, 0, sizeof sdir );
sdir.recnum = tdbio_new_recnum();
sdir.rectype= RECTYPE_SDIR;
sdir.r.sdir.lid = sdir.recnum;
sdir.r.sdir.keyid[0] = sig->keyid[0];
sdir.r.sdir.keyid[1] = sig->keyid[1];
sdir.r.sdir.pubkey_algo = sig->pubkey_algo;
sdir.r.sdir.hintlist = 0;
write_record( &sdir );
}
newlid = sdir.recnum;
/* Put the record number into the hintlist.
* (It is easier to use the lid and not the record number of the
* key to save some space (assuming that a signator has
* signed more than one user id - and it is easier to implement.)
*/
tmphlst.recnum = 0;
for( recno=sdir.r.sdir.hintlist; recno; recno = hlst.r.hlst.next) {
int i;
read_record( recno, &hlst, RECTYPE_HLST );
for( i=0; i < ITEMS_PER_HLST_RECORD; i++ ) {
if( !hlst.r.hlst.rnum[i] ) {
if( !tmphlst.recnum ) {
tmphlst = hlst;
tmpidx = i;
}
}
else if( hlst.r.hlst.rnum[i] == lid )
return newlid; /* the signature is already in the hintlist */
}
}
/* not yet in the hint list, write it */
if( tmphlst.recnum ) { /* we have an empty slot */
tmphlst.r.hlst.rnum[tmpidx] = lid;
write_record( &tmphlst );
}
else { /* must append a new hlst record */
memset( &hlst, 0, sizeof hlst );
hlst.recnum = tdbio_new_recnum();
hlst.rectype = RECTYPE_HLST;
hlst.r.hlst.next = sdir.r.sdir.hintlist;
hlst.r.hlst.rnum[0] = lid;
write_record( &hlst );
sdir.r.sdir.hintlist = hlst.recnum;
write_record( &sdir );
}
return newlid;
}
/****************
* This function checks the given public key and inserts or updates
* the keyrecord from the trustdb. Revocation certificates
* are handled here and the keybinding of subkeys is checked.
* Hmmm: Should we check here, that the key has at least one valid
* user ID or do we allow keys w/o user ID?
*
* keyblock points to the first node in the keyblock,
* keynode is the node with the public key to check
* (either primary or secondary), keyid is the keyid of
* the primary key, drec is the directory record and recno_list
* is a list used to keep track of visited records.
* Existing keyflags are recalculated if recheck is true.
*/
static void
upd_key_record( KBNODE keyblock, KBNODE keynode, u32 *keyid,
TRUSTREC *drec, RECNO_LIST *recno_list, int recheck )
{
TRUSTREC krec;
KBNODE node;
PKT_public_key *pk = keynode->pkt->pkt.public_key;
ulong lid = drec->recnum;
byte fpr[MAX_FINGERPRINT_LEN];
size_t fprlen;
ulong recno, newrecno;
int keybind_seen = 0;
int revoke_seen = 0;
int rc;
fingerprint_from_pk( pk, fpr, &fprlen );
/* do we already have this key? */
for( recno=drec->r.dir.keylist; recno; recno = krec.r.key.next ) {
read_record( recno, &krec, RECTYPE_KEY );
if( krec.r.key.fingerprint_len == fprlen
&& !memcmp( krec.r.key.fingerprint, fpr, fprlen ) )
break;
}
if( recno ) { /* yes */
ins_recno_list( recno_list, recno, RECTYPE_KEY );
}
else { /* no: insert this new key */
recheck = 1;
memset( &krec, 0, sizeof(krec) );
krec.rectype = RECTYPE_KEY;
krec.r.key.lid = lid;
krec.r.key.pubkey_algo = pk->pubkey_algo;
krec.r.key.fingerprint_len = fprlen;
memcpy(krec.r.key.fingerprint, fpr, fprlen );
krec.recnum = newrecno = tdbio_new_recnum();
write_record( &krec );
ins_recno_list( recno_list, newrecno, RECTYPE_KEY );
/* and put this new record at the end of the keylist */
if( !(recno=drec->r.dir.keylist) ) {
/* this is the first key */
drec->r.dir.keylist = newrecno;
drec->dirty = 1;
}
else { /* we already have a key, append the new one */
TRUSTREC save = krec;
for( ; recno; recno = krec.r.key.next )
read_record( recno, &krec, RECTYPE_KEY );
krec.r.key.next = newrecno;
write_record( &krec );
krec = save;
}
}
if( !recheck && (krec.r.key.keyflags & KEYF_CHECKED) )
return;
/* check keybindings and revocations */
krec.r.key.keyflags = 0;
if( keynode->pkt->pkttype == PKT_PUBLIC_KEY ) {
/* we assume that a primary key is always valid
* and check later whether we have a revocation */
krec.r.key.keyflags |= KEYF_CHECKED | KEYF_VALID;
}
for( node=keynode->next; node; node = node->next ) {
PKT_signature *sig;
if( node->pkt->pkttype == PKT_PUBLIC_SUBKEY )
break; /* ready */
else if( node->pkt->pkttype != PKT_SIGNATURE )
continue;
sig = node->pkt->pkt.signature;
if( keyid[0] != sig->keyid[0] || keyid[1] != sig->keyid[1] )
continue; /* not a self signature */
if( sig->sig_class == 0x18 && !keybind_seen ) { /* a keybinding */
if( keynode->pkt->pkttype == PKT_PUBLIC_KEY )
continue; /* oops, not for a main key */
/* we check until we find a valid keybinding */
rc = check_key_signature( keyblock, node, NULL );
if( !rc ) {
if( opt.verbose )
log_info(_(
"key %08lX.%lu: Good subkey binding\n"),
(ulong)keyid_from_pk(pk,NULL), lid );
krec.r.key.keyflags |= KEYF_CHECKED | KEYF_VALID;
}
else {
log_info(_(
"key %08lX.%lu: Invalid subkey binding: %s\n"),
(ulong)keyid_from_pk(pk,NULL), lid, g10_errstr(rc) );
krec.r.key.keyflags |= KEYF_CHECKED;
krec.r.key.keyflags &= ~KEYF_VALID;
}
keybind_seen = 1;
}
else if( sig->sig_class == 0x20 && !revoke_seen ) {
if( keynode->pkt->pkttype == PKT_PUBLIC_SUBKEY )
continue; /* a subkey is not expected here */
/* This is a key revocation certificate: check it */
rc = check_key_signature( keyblock, node, NULL );
if( !rc ) {
if( opt.verbose )
log_info(_(
"key %08lX.%lu: Valid key revocation\n"),
(ulong)keyid_from_pk(pk,NULL), lid );
krec.r.key.keyflags |= KEYF_REVOKED;
}
else {
log_info(_(
"key %08lX.%lu: Invalid key revocation: %s\n"),
(ulong)keyid_from_pk(pk,NULL), lid, g10_errstr(rc) );
}
revoke_seen = 1;
}
else if( sig->sig_class == 0x28 && !revoke_seen ) {
if( keynode->pkt->pkttype == PKT_PUBLIC_KEY )
continue; /* a mainkey is not expected here */
/* This is a subkey revocation certificate: check it */
/* fixme: we should also check the revocation
* is newer than the key (OpenPGP) */
rc = check_key_signature( keyblock, node, NULL );
if( !rc ) {
if( opt.verbose )
log_info(_(
"key %08lX.%lu: Valid subkey revocation\n"),
(ulong)keyid_from_pk(pk,NULL), lid );
krec.r.key.keyflags |= KEYF_REVOKED;
}
else {
log_info(_(
"key %08lX.%lu: Invalid subkey binding: %s\n"),
(ulong)keyid_from_pk(pk,NULL), lid, g10_errstr(rc) );
}
revoke_seen = 1;
}
}
write_record( &krec );
}
/****************
* This function checks the given user ID and inserts or updates
* the uid record of the trustdb. Revocation certificates
* are handled here.
*
* keyblock points to the first node in the keyblock,
* uidnode is the node with the user id to check
* keyid is the keyid of
* the primary key, drec is the directory record and recno_list
* is a list used to keep track of visited records.
* Existing uidflags are recalculated if recheck is true.
*/
static void
upd_uid_record( KBNODE keyblock, KBNODE uidnode, u32 *keyid,
TRUSTREC *drec, RECNO_LIST *recno_list, int recheck )
{
ulong lid = drec->recnum;
PKT_user_id *uid = uidnode->pkt->pkt.user_id;
TRUSTREC urec;
PKT_signature *selfsig = NULL;
byte uidhash[20];
KBNODE node;
ulong recno, newrecno;
int rc;
/* see whether we already have an uid record */
rmd160_hash_buffer( uidhash, uid->name, uid->len );
for( recno=drec->r.dir.uidlist; recno; recno = urec.r.uid.next ) {
read_record( recno, &urec, RECTYPE_UID );
if( !memcmp( uidhash, urec.r.uid.namehash, 20 ) )
break;
}
if( recno ) { /* we already have this record */
ins_recno_list( recno_list, recno, RECTYPE_UID );
}
else { /* new user id */
recheck = 1;
memset( &urec, 0 , sizeof(urec) );
urec.rectype = RECTYPE_UID;
urec.r.uid.lid = drec->recnum;
memcpy(urec.r.uid.namehash, uidhash, 20 );
urec.recnum = newrecno = tdbio_new_recnum();
write_record( &urec );
ins_recno_list( recno_list, newrecno, RECTYPE_UID );
/* and put this new record at the end of the uidlist */
if( !(recno=drec->r.dir.uidlist) ) { /* this is the first uid */
drec->r.dir.uidlist = newrecno;
drec->dirty = 1;
}
else { /* we already have an uid, append it to the list */
TRUSTREC save = urec;
for( ; recno; recno = urec.r.key.next )
read_record( recno, &urec, RECTYPE_UID );
urec.r.uid.next = newrecno;
write_record( &urec );
urec = save;
}
}
if( recheck || !(urec.r.uid.uidflags & UIDF_CHECKED) ) {
/* check self signatures */
urec.r.uid.uidflags = 0;
for( node=uidnode->next; node; node = node->next ) {
PKT_signature *sig;
if( node->pkt->pkttype == PKT_USER_ID )
break; /* ready */
if( node->pkt->pkttype == PKT_PUBLIC_SUBKEY )
break; /* ready */
if( node->pkt->pkttype != PKT_SIGNATURE )
continue;
sig = node->pkt->pkt.signature;
if( keyid[0] != sig->keyid[0] || keyid[1] != sig->keyid[1] )
continue; /* not a self signature */
if( (sig->sig_class&~3) == 0x10 ) { /* regular self signature */
rc = check_key_signature( keyblock, node, NULL );
if( !rc ) {
if( opt.verbose )
log_info( "uid %08lX.%lu/%02X%02X: %s\n",
(ulong)keyid[1], lid, uidhash[18], uidhash[19],
_("Good self-signature") );
urec.r.uid.uidflags |= UIDF_CHECKED | UIDF_VALID;
if( !selfsig )
selfsig = sig; /* use the first valid sig */
else if( sig->timestamp > selfsig->timestamp
&& sig->sig_class >= selfsig->sig_class )
selfsig = sig; /* but this one is newer */
}
else {
log_info( "uid %08lX/%02X%02X: %s: %s\n",
(ulong)keyid[1], uidhash[18], uidhash[19],
_("Invalid self-signature"),
g10_errstr(rc) );
urec.r.uid.uidflags |= UIDF_CHECKED;
}
}
else if( sig->sig_class == 0x30 ) { /* cert revocation */
rc = check_key_signature( keyblock, node, NULL );
if( !rc && selfsig && selfsig->timestamp > sig->timestamp ) {
log_info( "uid %08lX.%lu/%02X%02X: %s\n",
(ulong)keyid[1], lid, uidhash[18], uidhash[19],
_("Valid user ID revocation skipped "
"due to a newer self signature\n") );
}
else if( !rc ) {
if( opt.verbose )
log_info( "uid %08lX.%lu/%02X%02X: %s\n",
(ulong)keyid[1], lid, uidhash[18], uidhash[19],
_("Valid user ID revocation\n") );
urec.r.uid.uidflags |= UIDF_CHECKED | UIDF_VALID;
urec.r.uid.uidflags |= UIDF_REVOKED;
}
else {
log_info("uid %08lX/%02X%02X: %s: %s\n",
(ulong)keyid[1], uidhash[18], uidhash[19],
_("Invalid user ID revocation"),
g10_errstr(rc) );
}
}
}
write_record( &urec );
} /* end check self-signatures */
if( (urec.r.uid.uidflags & (UIDF_CHECKED|UIDF_VALID))
!= (UIDF_CHECKED|UIDF_VALID) )
return; /* user ID is not valid, so no need to check more things */
/* check the preferences */
if( selfsig )
upd_pref_record( &urec, keyid, selfsig );
/* check non-self signatures */
for( node=uidnode->next; node; node = node->next ) {
PKT_signature *sig;
if( node->pkt->pkttype == PKT_USER_ID )
break; /* ready */
if( node->pkt->pkttype == PKT_PUBLIC_SUBKEY )
break; /* ready */
if( node->pkt->pkttype != PKT_SIGNATURE )
continue;
sig = node->pkt->pkt.signature;
if( keyid[0] == sig->keyid[0] || keyid[1] == sig->keyid[1] )
continue; /* skip self signature */
if( (sig->sig_class&~3) == 0x10 ) { /* regular certification */
upd_cert_record( keyblock, node, keyid, drec, recno_list,
recheck, &urec, uidhash, 0 );
}
else if( sig->sig_class == 0x30 ) { /* cert revocation */
upd_cert_record( keyblock, node, keyid, drec, recno_list,
recheck, &urec, uidhash, 1 );
}
} /* end check certificates */
write_record( &urec );
}
/****************
*
*
*/
static void
upd_pref_record( TRUSTREC *urec, u32 *keyid, PKT_signature *sig )
{
static struct {
sigsubpkttype_t subpkttype;
int preftype;
} ptable[] = {
{ SIGSUBPKT_PREF_SYM, PREFTYPE_SYM },
{ SIGSUBPKT_PREF_HASH, PREFTYPE_HASH },
{ SIGSUBPKT_PREF_COMPR, PREFTYPE_COMPR },
{ 0, 0 }
};
TRUSTREC prec;
ulong lid = urec->r.uid.lid ;
const byte *uidhash = urec->r.uid.namehash;
const byte *s;
size_t n;
int k, i;
ulong recno;
byte prefs_sig[200];
int n_prefs_sig = 0;
byte prefs_rec[200];
int n_prefs_rec = 0;
/* check for changed preferences */
for(k=0; ptable[k].subpkttype; k++ ) {
s = parse_sig_subpkt2( sig, ptable[k].subpkttype, &n );
if( s ) {
for( ; n; n--, s++ ) {
if( n_prefs_sig >= DIM(prefs_sig)-1 ) {
log_info("uid %08lX.%lu/%02X%02X: %s\n",
(ulong)keyid[1], lid, uidhash[18], uidhash[19],
_("Too many preferences") );
break;
}
prefs_sig[n_prefs_sig++] = ptable[k].preftype;
prefs_sig[n_prefs_sig++] = *s;
}
}
}
for( recno=urec->r.uid.prefrec; recno; recno = prec.r.pref.next ) {
read_record( recno, &prec, RECTYPE_PREF );
for(i = 0; i < ITEMS_PER_PREF_RECORD; i +=2 ) {
if( n_prefs_rec >= DIM(prefs_rec)-1 ) {
log_info("uid %08lX.%lu/%02X%02X: %s\n",
(ulong)keyid[1], lid, uidhash[18], uidhash[19],
_("Too many preference items") );
break;
}
if( prec.r.pref.data[i] ) {
prefs_rec[n_prefs_rec++] = prec.r.pref.data[i];
prefs_rec[n_prefs_rec++] = prec.r.pref.data[i+1];
}
}
}
if( n_prefs_sig == n_prefs_rec
&& !memcmp( prefs_sig, prefs_rec, n_prefs_sig ) )
return; /* not changed */
/* Preferences have changed: Delete all pref records
* This is much simpler than checking whether we have to
* do update the record at all - the record cache may care about it
*/
for( recno=urec->r.uid.prefrec; recno; recno = prec.r.pref.next ) {
read_record( recno, &prec, RECTYPE_PREF );
delete_record( recno );
}
if( n_prefs_sig > ITEMS_PER_PREF_RECORD )
log_info(_("WARNING: can't yet handle long pref records\n"));
memset( &prec, 0, sizeof prec );
prec.recnum = tdbio_new_recnum();
prec.rectype = RECTYPE_PREF;
prec.r.pref.lid = lid;
if( n_prefs_sig <= ITEMS_PER_PREF_RECORD )
memcpy( prec.r.pref.data, prefs_sig, n_prefs_sig );
else { /* need more than one pref record */
TRUSTREC tmp;
ulong nextrn;
int n = n_prefs_sig;
byte *pp = prefs_sig;
memcpy( prec.r.pref.data, pp, ITEMS_PER_PREF_RECORD );
n -= ITEMS_PER_PREF_RECORD;
pp += ITEMS_PER_PREF_RECORD;
nextrn = prec.r.pref.next = tdbio_new_recnum();
do {
memset( &tmp, 0, sizeof tmp );
tmp.recnum = nextrn;
tmp.rectype = RECTYPE_PREF;
tmp.r.pref.lid = lid;
if( n <= ITEMS_PER_PREF_RECORD ) {
memcpy( tmp.r.pref.data, pp, n );
n = 0;
}
else {
memcpy( tmp.r.pref.data, pp, ITEMS_PER_PREF_RECORD );
n -= ITEMS_PER_PREF_RECORD;
pp += ITEMS_PER_PREF_RECORD;
nextrn = tmp.r.pref.next = tdbio_new_recnum();
}
write_record( &tmp );
} while( n );
}
write_record( &prec );
urec->r.uid.prefrec = prec.recnum;
urec->dirty = 1;
}
static void
upd_cert_record( KBNODE keyblock, KBNODE signode, u32 *keyid,
TRUSTREC *drec, RECNO_LIST *recno_list, int recheck,
TRUSTREC *urec, const byte *uidhash, int revoke )
{
/* We simply insert the signature into the sig records but
* avoid duplicate ones. We do not check them here because
* there is a big chance, that we import required public keys
* later. The problem with this is that we must somewhere store
* the information about this signature (we need a record id).
* We do this by using the record type shadow dir, which will
* be converted to a dir record as soon as a new public key is
* inserted into the trustdb.
*/
ulong lid = drec->recnum;
PKT_signature *sig = signode->pkt->pkt.signature;
TRUSTREC rec;
ulong recno;
TRUSTREC delrec;
int delrecidx=0;
int newflag = 0;
ulong newlid = 0;
PKT_public_key *pk = m_alloc_clear( sizeof *pk );
ulong pk_lid = 0;
int found_sig = 0;
int found_delrec = 0;
int rc;
delrec.recnum = 0;
/* get the LID of the pubkey of the signature under verification */
rc = get_pubkey( pk, sig->keyid );
if( !rc ) {
if( pk->local_id )
pk_lid = pk->local_id;
else {
rc = tdbio_search_dir_bypk( pk, &rec );
if( !rc )
pk_lid = rec.recnum;
else if( rc == -1 ) { /* see whether there is a sdir instead */
u32 akid[2];
keyid_from_pk( pk, akid );
rc = tdbio_search_sdir( akid, pk->pubkey_algo, &rec );
if( !rc )
pk_lid = rec.recnum;
}
}
}
free_public_key( pk ); pk = NULL;
/* Loop over all signatures just in case one is not correctly
* marked. If we see the correct signature, set a flag.
* delete duplicate signatures (should not happen but...) */
for( recno = urec->r.uid.siglist; recno; recno = rec.r.sig.next ) {
int i;
read_record( recno, &rec, RECTYPE_SIG );
for(i=0; i < SIGS_PER_RECORD; i++ ) {
TRUSTREC tmp;
if( !rec.r.sig.sig[i].lid ) {
if( !found_delrec && !delrec.recnum ) {
delrec = rec;
delrecidx = i;
found_delrec=1;
}
continue; /* skip deleted sigs */
}
if( rec.r.sig.sig[i].lid == pk_lid ) {
if( found_sig ) {
log_info( "sig %08lX.%lu/%02X%02X/%08lX: %s\n",
(ulong)keyid[1], lid, uidhash[18],
uidhash[19], (ulong)sig->keyid[1],
_("Duplicated certificate - deleted") );
rec.r.sig.sig[i].lid = 0;
rec.dirty = 1;
continue;
}
found_sig = 1;
}
if( !recheck && !revoke && (rec.r.sig.sig[i].flag & SIGF_CHECKED) )
continue; /* we already checked this signature */
if( !recheck && (rec.r.sig.sig[i].flag & SIGF_NOPUBKEY) )
continue; /* we do not have the public key */
read_record( rec.r.sig.sig[i].lid, &tmp, 0 );
if( tmp.rectype == RECTYPE_DIR ) {
/* In this case we should now be able to check the signature */
rc = check_key_signature( keyblock, signode, NULL );
if( !rc ) { /* valid signature */
if( opt.verbose )
log_info("sig %08lX.%lu/%02X%02X/%08lX: %s\n",
(ulong)keyid[1], lid, uidhash[18],
uidhash[19], (ulong)sig->keyid[1],
revoke? _("Valid certificate revocation")
: _("Good certificate") );
rec.r.sig.sig[i].flag = SIGF_CHECKED | SIGF_VALID;
if( revoke )
rec.r.sig.sig[i].flag |= SIGF_REVOKED;
}
else if( rc == G10ERR_NO_PUBKEY ) {
#if 0 /* fixme: For some reason this really happens? */
if( (rec.r.sig.sig[i].flag & SIGF_CHECKED) )
log_info("sig %08lX.%lu/%02X%02X/%08lX: %s\n",
(ulong)keyid[1], lid, uidhash[18],
uidhash[19], (ulong)sig->keyid[1],
_("Hmmm, public key lost?") );
#endif
rec.r.sig.sig[i].flag = SIGF_NOPUBKEY;
if( revoke )
rec.r.sig.sig[i].flag |= SIGF_REVOKED;
}
else {
log_info("sig %08lX.%lu/%02X%02X/%08lX: %s: %s\n",
(ulong)keyid[1], lid, uidhash[18],
uidhash[19], (ulong)sig->keyid[1],
revoke? _("Invalid certificate revocation")
: _("Invalid certificate"),
g10_errstr(rc));
rec.r.sig.sig[i].flag = SIGF_CHECKED;
if( revoke )
rec.r.sig.sig[i].flag |= SIGF_REVOKED;
}
rec.dirty = 1;
}
else if( tmp.rectype == RECTYPE_SDIR ) {
/* must check that it is the right one */
if( tmp.r.sdir.keyid[0] == sig->keyid[0]
&& tmp.r.sdir.keyid[1] == sig->keyid[1]
&& (!tmp.r.sdir.pubkey_algo
|| tmp.r.sdir.pubkey_algo == sig->pubkey_algo )) {
if( !(rec.r.sig.sig[i].flag & SIGF_NOPUBKEY) )
log_info(_("uid %08lX.%lu/%02X%02X: "
"has shadow dir %lu but is not yet marked.\n"),
(ulong)keyid[1], lid,
uidhash[18], uidhash[19], tmp.recnum );
rec.r.sig.sig[i].flag = SIGF_NOPUBKEY;
if( revoke )
rec.r.sig.sig[i].flag |= SIGF_REVOKED;
rec.dirty = 1;
/* fixme: should we verify that the record is
* in the hintlist? - This case here should anyway
* never occur */
}
}
else {
log_error(_("sig record %lu[%d] points to wrong record.\n"),
rec.r.sig.sig[i].lid, i );
die_invalid_db();
}
}
if( found_delrec && delrec.recnum ) {
delrec = rec;
found_delrec = 0; /* we only want the first one */
}
if( rec.dirty ) {
write_record( &rec );
rec.dirty = 0;
}
}
if( found_sig )
return;
/* at this point, we have verified, that the signature is not in
* our list of signatures. Add a new record with that signature
* and if the public key is there, check the signature. */
if( !pk_lid ) /* we have already seen that there is no pubkey */
rc = G10ERR_NO_PUBKEY;
else
rc = check_key_signature( keyblock, signode, NULL );
if( !rc ) { /* valid signature */
if( opt.verbose )
log_info("sig %08lX.%lu/%02X%02X/%08lX: %s\n",
(ulong)keyid[1], lid, uidhash[18],
uidhash[19], (ulong)sig->keyid[1],
revoke? _("Valid certificate revocation")
: _("Good certificate") );
newlid = pk_lid; /* this is the pk of the signature */
newflag = SIGF_CHECKED | SIGF_VALID;
if( revoke )
newflag |= SIGF_REVOKED;
}
else if( rc == G10ERR_NO_PUBKEY ) {
if( opt.verbose > 1 )
log_info("sig %08lX.%lu/%02X%02X/%08lX: %s\n",
(ulong)keyid[1], lid, uidhash[18],
uidhash[19], (ulong)sig->keyid[1], g10_errstr(rc) );
newlid = create_shadow_dir( sig, lid );
newflag = SIGF_NOPUBKEY;
if( revoke )
newflag |= SIGF_REVOKED;
}
else {
log_info( "sig %08lX.%lu/%02X%02X/%08lX: %s: %s\n",
(ulong)keyid[1], lid, uidhash[18], uidhash[19],
(ulong)sig->keyid[1],
revoke? _("Invalid certificate revocation")
: _("Invalid certificate"),
g10_errstr(rc));
newlid = create_shadow_dir( sig, lid );
newflag = SIGF_CHECKED;
if( revoke )
newflag |= SIGF_REVOKED;
}
if( delrec.recnum ) { /* we can reuse a deleted/unused slot */
delrec.r.sig.sig[delrecidx].lid = newlid;
delrec.r.sig.sig[delrecidx].flag= newflag;
write_record( &delrec );
}
else { /* must insert a new sig record */
TRUSTREC tmp;
memset( &tmp, 0, sizeof tmp );
tmp.recnum = tdbio_new_recnum();
tmp.rectype = RECTYPE_SIG;
tmp.r.sig.lid = lid;
tmp.r.sig.next = urec->r.uid.siglist;
tmp.r.sig.sig[0].lid = newlid;
tmp.r.sig.sig[0].flag= newflag;
write_record( &tmp );
urec->r.uid.siglist = tmp.recnum;
urec->dirty = 1;
}
}
/****************
* Update all the info from the public keyblock.
* The key must already exist in the keydb.
* This function is responsible for checking the signatures in cases
* where the public key is already available. If we do not have the public
* key, the check is done by some special code in insert_trust_record().
*/
int
update_trust_record( KBNODE keyblock, int recheck, int *modified )
{
PKT_public_key *primary_pk;
KBNODE node;
TRUSTREC drec;
TRUSTREC krec;
TRUSTREC urec;
TRUSTREC prec;
TRUSTREC helprec;
int rc = 0;
u32 keyid[2]; /* keyid of primary key */
ulong recno, lastrecno;
RECNO_LIST recno_list = NULL; /* list of verified records */
/* fixme: replace recno_list by a lookup on node->recno */
if( modified )
*modified = 0;
node = find_kbnode( keyblock, PKT_PUBLIC_KEY );
primary_pk = node->pkt->pkt.public_key;
rc = get_dir_record( primary_pk, &drec );
if( rc )
return rc;
if( !primary_pk->local_id )
primary_pk->local_id = drec.recnum;
keyid_from_pk( primary_pk, keyid );
/* fixme: check that the keyblock has a valid structure */
rc = tdbio_begin_transaction();
if( rc )
return rc;
/* update the keys */
for( node=keyblock; node; node = node->next ) {
if( node->pkt->pkttype == PKT_PUBLIC_KEY
|| node->pkt->pkttype == PKT_PUBLIC_SUBKEY )
upd_key_record( keyblock, node, keyid,
&drec, &recno_list, recheck );
}
/* update the user IDs */
for( node=keyblock; node; node = node->next ) {
if( node->pkt->pkttype == PKT_USER_ID )
upd_uid_record( keyblock, node, keyid,
&drec, &recno_list, recheck );
}
/* delete keyrecords from the trustdb which are not anymore used */
/* should we really do this, or is it better to keep them and */
/* mark as unused? */
lastrecno = 0;
for( recno=drec.r.dir.keylist; recno; recno = krec.r.key.next ) {
read_record( recno, &krec, RECTYPE_KEY );
if( !qry_recno_list( recno_list, recno, RECTYPE_KEY ) ) {
/* delete this one */
if( !lastrecno ) {
drec.r.dir.keylist = krec.r.key.next;
drec.dirty = 1;
}
else {
read_record( lastrecno, &helprec, RECTYPE_KEY );
helprec.r.key.next = krec.r.key.next;
write_record( &helprec );
}
delete_record( recno );
}
else
lastrecno = recno;
}
/* delete uid records and sig and their pref records from the
* trustdb which are not anymore used */
lastrecno = 0;
for( recno=drec.r.dir.uidlist; recno; recno = urec.r.uid.next ) {
read_record( recno, &urec, RECTYPE_UID );
if( !qry_recno_list( recno_list, recno, RECTYPE_UID ) ) {
ulong r2;
/* delete this one */
if( !lastrecno ) {
drec.r.dir.uidlist = urec.r.uid.next;
drec.dirty = 1;
}
else {
read_record( lastrecno, &helprec, RECTYPE_UID );
helprec.r.uid.next = urec.r.uid.next;
write_record( &helprec );
}
for(r2=urec.r.uid.prefrec ; r2; r2 = prec.r.pref.next ) {
read_record( r2, &prec, RECTYPE_PREF );
delete_record( r2 );
}
for(r2=urec.r.uid.siglist ; r2; r2 = helprec.r.sig.next ) {
read_record( r2, &helprec, RECTYPE_SIG );
delete_record( r2 );
}
delete_record( recno );
}
else
lastrecno = recno;
}
if( rc )
rc = tdbio_cancel_transaction();
else {
drec.r.dir.dirflags |= DIRF_CHECKED;
drec.r.dir.dirflags &= ~DIRF_VALVALID;
write_record( &drec );
if( modified && tdbio_is_dirty() )
*modified = 1;
rc = tdbio_end_transaction();
}
rel_recno_list( &recno_list );
return rc;
}
/****************
* Insert a trust record into the TrustDB
* This function assumes that the record does not yet exist.
*/
int
insert_trust_record( PKT_public_key *pk )
{
TRUSTREC dirrec;
TRUSTREC shadow;
KBNODE keyblock = NULL;
KBNODE node;
byte fingerprint[MAX_FINGERPRINT_LEN];
size_t fingerlen;
int rc = 0;
ulong hintlist = 0;
if( pk->local_id )
log_bug("pk->local_id=%lu\n", pk->local_id );
fingerprint_from_pk( pk, fingerprint, &fingerlen );
/* fixme: assert that we do not have this record.
* we can do this by searching for the primary keyid
*
* fixme: If there is no such key we should look whether one
* of the subkeys has been used to sign another key and in this case
* we got the key anyway. Because a secondary key can't be used
* without a primary key (it is needed to bind the secondary one
* to the primary one which has the user ids etc.)
*/
/* get the keyblock which has the key */
rc = get_keyblock_byfprint( &keyblock, fingerprint, fingerlen );
if( rc ) { /* that should never happen */
log_error( _("insert_trust_record: keyblock not found: %s\n"),
g10_errstr(rc) );
goto leave;
}
/* check that we used the primary key (we are little bit paranoid) */
{ PKT_public_key *a_pk;
u32 akid[2], bkid[2];
node = find_kbnode( keyblock, PKT_PUBLIC_KEY );
a_pk = node->pkt->pkt.public_key;
/* we can't use cmp_public_keys here because some parts (expiredate)
* might not be set in pk <--- but why (fixme) */
keyid_from_pk( a_pk, akid );
keyid_from_pk( pk, bkid );
if( akid[0] != bkid[0] || akid[1] != bkid[1] ) {
log_error(_("did not use primary key for insert_trust_record()\n"));
rc = G10ERR_GENERAL;
goto leave;
}
}
/* We have to look for a shadow dir record which must be reused
* as the dir record. And: check all signatures which are listed
* in the hintlist of the shadow dir record.
*/
rc = tdbio_search_sdir( pk->keyid, pk->pubkey_algo, &shadow );
if( rc && rc != -1 ) {
log_error(_("tdbio_search_dir failed: %s\n"), g10_errstr(rc));
die_invalid_db();
}
memset( &dirrec, 0, sizeof dirrec );
dirrec.rectype = RECTYPE_DIR;
if( !rc ) {
/* hey, great: this key has already signed other keys
* convert this to a real directory entry */
hintlist = shadow.r.sdir.hintlist;
dirrec.recnum = shadow.recnum;
}
else {
dirrec.recnum = tdbio_new_recnum();
}
dirrec.r.dir.lid = dirrec.recnum;
write_record( &dirrec );
/* store the LID */
pk->local_id = dirrec.r.dir.lid;
for( node=keyblock; node; node = node->next ) {
if( node->pkt->pkttype == PKT_PUBLIC_KEY
|| node->pkt->pkttype == PKT_PUBLIC_SUBKEY ) {
PKT_public_key *pk = node->pkt->pkt.public_key;
pk->local_id = dirrec.r.dir.lid;
}
else if( node->pkt->pkttype == PKT_SIGNATURE ) {
PKT_signature *sig = node->pkt->pkt.signature;
sig->local_id = dirrec.r.dir.lid;
}
}
/* and put all the other stuff into the keydb */
rc = update_trust_record( keyblock, 1, NULL );
if( !rc )
process_hintlist( hintlist, dirrec.r.dir.lid );
leave:
if( rc && hintlist )
; /* fixme: the hintlist is not anymore anchored */
release_kbnode( keyblock );
do_sync();
return rc;
}
int
update_ownertrust( ulong lid, unsigned new_trust )
{
TRUSTREC rec;
read_record( lid, &rec, RECTYPE_DIR );
rec.r.dir.ownertrust = new_trust;
write_record( &rec );
do_sync();
return 0;
}
diff --git a/g10/trustdb.h b/g10/trustdb.h
index 933d7a58d..fd92826ba 100644
--- a/g10/trustdb.h
+++ b/g10/trustdb.h
@@ -1,71 +1,72 @@
/* trustdb.h - Trust database
* Copyright (C) 1998 Free Software Foundation, Inc.
*
* This file is part of GNUPG.
*
* GNUPG 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.
*
* GNUPG 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
*/
#ifndef G10_TRUSTDB_H
#define G10_TRUSTDB_H
/* Trust values must be sorted in ascending order */
#define TRUST_MASK 15
#define TRUST_UNKNOWN 0 /* o: not yet calculated */
#define TRUST_EXPIRED 1 /* e: calculation may be invalid */
#define TRUST_UNDEFINED 2 /* q: not enough information for calculation */
#define TRUST_NEVER 3 /* n: never trust this pubkey */
#define TRUST_MARGINAL 4 /* m: marginally trusted */
#define TRUST_FULLY 5 /* f: fully trusted */
#define TRUST_ULTIMATE 6 /* u: ultimately trusted */
/* trust values not covered by the mask */
#define TRUST_FLAG_REVOKED 32 /* r: revoked */
#define PREFTYPE_SYM 1
#define PREFTYPE_HASH 2
#define PREFTYPE_COMPR 3
/*-- trustdb.c --*/
void list_trustdb(const char *username);
void list_trust_path( const char *username );
void export_ownertrust(void);
void import_ownertrust(const char *fname);
void register_trusted_key( const char *string );
void check_trustdb( const char *username );
void update_trustdb( void );
int init_trustdb( int level, const char *dbname );
int check_trust( PKT_public_key *pk, unsigned *r_trustlevel );
int query_trust_info( PKT_public_key *pk );
int enum_cert_paths( void **context, ulong *lid,
unsigned *ownertrust, unsigned *validity );
+int enum_cert_paths_print( void **context, FILE *fp, ulong selected_lid );
unsigned get_ownertrust( ulong lid );
int get_ownertrust_info( ulong lid );
byte *get_pref_data( ulong lid, const byte *namehash, size_t *ret_n );
int is_algo_in_prefs( ulong lid, int preftype, int algo );
int keyid_from_lid( ulong lid, u32 *keyid );
ulong lid_from_keyblock( KBNODE keyblock );
int query_trust_record( PKT_public_key *pk );
int clear_trust_checked_flag( PKT_public_key *pk );
int insert_trust_record( PKT_public_key *pk );
int update_trust_record( KBNODE keyblock, int fast, int *modified );
int update_ownertrust( ulong lid, unsigned new_trust );
/*-- pkclist.c --*/
int edit_ownertrust( ulong lid, int mode );
#endif /*G10_TRUSTDB_H*/
diff --git a/po/ChangeLog b/po/ChangeLog
index 8f69e8f11..13da187a1 100644
--- a/po/ChangeLog
+++ b/po/ChangeLog
@@ -1,78 +1,82 @@
+Thu Dec 17 18:31:15 CET 1998 Werner Koch <wk@isil.d.shuttle.de>
+
+ * fr.po: Imported new version
+
Mon Dec 14 21:18:49 CET 1998 Werner Koch <wk@isil.d.shuttle.de>
* de.po: Imported new version.
Thu Dec 10 20:15:36 CET 1998 Werner Koch <wk@isil.d.shuttle.de>
* *.po: Changed some english strings.
Tue Dec 8 15:09:29 CET 1998 Werner Koch <wk@isil.d.shuttle.de>
* pt_BR.po: Add translation by Thiago Jung Bauermann.
Fri Nov 27 12:39:29 CET 1998 Werner Koch <wk@isil.d.shuttle.de>
* en.po: Removed
Fri Nov 20 11:46:22 1998 Werner Koch (wk@isil.d.shuttle.de)
* de.po: Imported new version
* de.glo: Glossary used for de.po.
Sat Nov 14 10:16:59 1998 Werner Koch (wk@isil.d.shuttle.de)
* es_ES.po: New translation by Urko Lusa.
Tue Nov 10 10:48:02 1998 Werner Koch (wk@isil.d.shuttle.de)
* it.po: Imported new version.
Fri Oct 30 20:03:17 1998 Werner Koch (wk@isil.d.shuttle.de)
* fr.po: Imported new version
Mon Oct 12 09:08:09 1998 Werner Koch (wk@isil.d.shuttle.de)
* it.po: Imported new version.
* de.po: Imported new version.
Sun Oct 11 16:24:27 1998 Werner Koch (wk@isil.d.shuttle.de)
* fr.po: Imported new version
Wed Oct 7 13:12:00 1998 Werner Koch (wk@isil.d.shuttle.de)
* Makefile.in.in: Fixed mkinstalldirs problems
Mon Sep 21 15:03:44 1998 Werner Koch (wk@(none))
* it.po: New version from Marco d'Itri
Mon Sep 21 09:28:54 1998 Werner Koch (wk@(none))
* fr.po: New version from Gaël Quéri
Tue Aug 11 12:28:11 1998 Werner Koch (wk@(none))
* it.po: New file from Marco.
Thu Jul 9 21:14:51 1998 Werner Koch (wk@isil.d.shuttle.de)
* de.po: Fixed typos and added new translations.
Fri Jun 26 11:44:24 1998 Werner Koch (wk@isil.d.shuttle.de)
* it.po: New file from Marco.
Thu May 28 10:44:25 1998 Werner Koch (wk@isil.d.shuttle.de)
* it.po: Add small corrections from Marco
Thu Apr 9 10:03:14 1998 Werner Koch (wk@isil.d.shuttle.de)
* it.po: New version from Marco
Fri Mar 13 09:43:19 1998 Werner Koch (wk@isil.d.shuttle.de)
* it.po: New
diff --git a/po/de.po b/po/de.po
index c3fded59d..a3b700a80 100644
--- a/po/de.po
+++ b/po/de.po
@@ -1,3245 +1,3245 @@
# GnuPG german translation
# Copyright (C) 1998 Free Software Foundation, Inc.
# Walter Koch <walterk@dip.de>, 1998.
#
msgid ""
msgstr ""
"POT-Creation-Date: 1998-12-09 00:39+0100\n"
"PO-Revision-Date: 1998-12-13 22:34+0100\n"
"Last-Translator: Walter Koch <walterk@mail.dip.de>\n"
"Language-Team: German <de@li.org>\n"
"MIME-Version: 1.0\n"
"Content-Type: text/plain; charset=\n"
"Date: 1998-01-26 22:08:36+0100\n"
"From: Werner Koch <wk@frodo>\n"
"Xgettext-Options: --default-domain=gnupg --directory=.. --add-comments "
"--keyword=_ --keyword=N_ --files-from=./POTFILES.in\n"
"Files: util/secmem.c util/argparse.c cipher/random.c cipher/rand-dummy.c "
"cipher/rand-unix.c cipher/rand-w32.c g10/g10.c g10/pkclist.c g10/keygen.c "
"g10/decrypt.c g10/encode.c g10/import.c g10/keyedit.c g10/keylist.c "
"g10/mainproc.c g10/passphrase.c g10/plaintext.c g10/pref.c g10/seckey-cert.c "
"g10/sig-check.c g10/sign.c g10/trustdb.c g10/verify.c\n"
#: util/secmem.c:77
msgid "Warning: using insecure memory!\n"
msgstr ""
"Warnung: Sensible Daten könnten auf Platte ausgelagert werden.\n"
" Um dies zu vermeiden, kann das Programm suid(root) installiert werden.\n"
" Bitte wenden Sie sich hierzu an den Systemadministrator.\n"
#: util/miscutil.c:143
msgid "yes"
msgstr "ja"
#: util/miscutil.c:144
msgid "yY"
msgstr "jJ"
#: util/errors.c:54
msgid "General error"
msgstr "Allgemeiner Fehler"
#: util/errors.c:55
msgid "Unknown packet type"
msgstr "Unbekannter Pakettyp"
#: util/errors.c:56
msgid "Unknown version"
msgstr "Unbekannte Version"
#: util/errors.c:57
msgid "Unknown pubkey algorithm"
msgstr "Unbekanntes Public-Key Verfahren"
#: util/errors.c:58
msgid "Unknown digest algorithm"
msgstr "Unbekanntes Hashverfahren"
#: util/errors.c:59
msgid "Bad public key"
msgstr "Falscher öffentlicher Schüssel"
#: util/errors.c:60
msgid "Bad secret key"
msgstr "Falscher geheimer Schlüssel"
#: util/errors.c:61
msgid "Bad signature"
msgstr "Falsche Unterschrift"
#: util/errors.c:62
msgid "Checksum error"
msgstr "Prüfsummen-Fehler"
#: util/errors.c:63
msgid "Bad passphrase"
msgstr "Falsches Mantra"
#: util/errors.c:64
msgid "Public key not found"
msgstr "Öffentlicher Schlüssel nicht gefunden"
#: util/errors.c:65
msgid "Unknown cipher algorithm"
msgstr "Unbekanntes Verschlüsselungsverfahren"
#: util/errors.c:66
msgid "Can't open the keyring"
msgstr "Der Schlüsselbund kann nicht geöffnet werden"
#: util/errors.c:67
msgid "Invalid packet"
msgstr "Ungültiges Paket"
#: util/errors.c:68
msgid "Invalid armor"
msgstr "Ungültige ASCII-Hülle"
#: util/errors.c:69
msgid "No such user id"
msgstr "Keine User-ID"
#: util/errors.c:70
msgid "Secret key not available"
msgstr "Geheimer Schlüssel ist nicht vorhanden"
#: util/errors.c:71
msgid "Wrong secret key used"
msgstr "Falscher geheimer Schlüssel benutzt"
#: util/errors.c:72
msgid "Not supported"
msgstr "Wird nicht unterstützt"
#: util/errors.c:73
msgid "Bad key"
msgstr "Falscher Schlüssel"
#: util/errors.c:74
msgid "File read error"
msgstr "Dateilesefehler"
#: util/errors.c:75
msgid "File write error"
msgstr "Dateischreibfehler"
#: util/errors.c:76
msgid "Unknown compress algorithm"
msgstr "Unbekanntes Komprimierverfahren"
#: util/errors.c:77
msgid "File open error"
msgstr "Fehler beim Öffnen der Datei"
#: util/errors.c:78
msgid "File create error"
msgstr "Fehler beim Erzeugen der Datei"
#: util/errors.c:79
msgid "Invalid passphrase"
msgstr "Ungültiges Mantra"
#: util/errors.c:80
msgid "Unimplemented pubkey algorithm"
msgstr "Öffentliches Schlüsselverfahren ist nicht implementiert."
#: util/errors.c:81
msgid "Unimplemented cipher algorithm"
msgstr "Verschlüsselungsverfahren ist nicht implementiert"
#: util/errors.c:82
msgid "Unknown signature class"
msgstr "Unbekannte Unterschriftenklasse"
#: util/errors.c:83
msgid "Trust database error"
msgstr "Fehler in der Trust-DB"
#: util/errors.c:84
msgid "Bad MPI"
msgstr "Falsche MPI"
#: util/errors.c:85
msgid "Resource limit"
msgstr "Zu wenig Resourcen"
#: util/errors.c:86
msgid "Invalid keyring"
msgstr "Ungültiger Schlüsselbund"
#: util/errors.c:87
msgid "Bad certificate"
msgstr "Falsches Zertifikat"
#: util/errors.c:88
msgid "Malformed user id"
msgstr "Ungünstig aufgebaute User-ID"
#: util/errors.c:89
msgid "File close error"
msgstr "Fehler beim Schließen der Datei"
#: util/errors.c:90
msgid "File rename error"
msgstr "Fehler beim Umbenennen einer Datei"
#: util/errors.c:91
msgid "File delete error"
msgstr "Fehler beim Löschen einer Datei"
#: util/errors.c:92
msgid "Unexpected data"
msgstr "Unerwartete Daten"
#: util/errors.c:93
msgid "Timestamp conflict"
msgstr "Zeitangaben differieren"
#: util/errors.c:94
msgid "Unusable pubkey algorithm"
msgstr "Unbenutzbares öffentliches Schlüsselverfahren"
#: util/errors.c:95
msgid "File exists"
msgstr "Datei existiert bereits"
#: util/errors.c:96
msgid "Weak key"
msgstr "Unsicherer Schlüssel"
#: util/logger.c:178
#, c-format
msgid "... this is a bug (%s:%d:%s)\n"
msgstr "Ohhh jeeee ... dies ist eine Wanze (Programmfehler) (%s:%d:%s)\n"
#: util/logger.c:184
#, c-format
msgid "you found a bug ... (%s:%d)\n"
msgstr "Sie haben eine Wanze (Programmfehler) gefunden ... (%s:%d)\n"
#: cipher/random.c:379
msgid "WARNING: using insecure random number generator!!\n"
msgstr "WARNUNG: Der Zufallszahlengenerator erzeugt keine echten Zufallszahlen!\n"
#: cipher/random.c:380
msgid ""
"The random number generator is only a kludge to let\n"
"it run - it is in no way a strong RNG!\n"
"\n"
"DON'T USE ANY DATA GENERATED BY THIS PROGRAM!!\n"
"\n"
msgstr ""
"Der Zufallszahlengenerator (RNG) ist lediglich ein \"kludge\", um das\n"
"Übersetzen des Programms zu ermöglichen - es ist KEIN starker RNG!\n"
"\n"
"BENUTZEN SIE DIE DURCH DIESES PROGRAMM ERZEUGTEN DATEN NICHT!\n"
"\n"
#: cipher/rndlinux.c:154
#, c-format
msgid ""
"\n"
"Not enough random bytes available. Please do some other work to give\n"
"the OS a chance to collect more entropy! (Need %d more bytes)\n"
msgstr ""
"\n"
"Es sind nicht genügend Zufallswerte vorhanden. Bitte führen Sie andere\n"
"Arbeiten durch, damit das Betriebssystem weitere Entropie sammeln kann!\n"
"(Es werden noch %d Byte benötigt.)\n"
#: g10/g10.c:158
msgid ""
"@Commands:\n"
" "
msgstr ""
"@Kommandos:\n"
" "
#: g10/g10.c:161
msgid "|[file]|make a signature"
msgstr "|[file]|Eine Unterschrift erzeugen"
#: g10/g10.c:162
msgid "|[file]|make a clear text signature"
msgstr "|[file]|Eine Klartextunterschrift erzeugen"
#: g10/g10.c:163
msgid "make a detached signature"
msgstr "Eine abgetrennte Unterschrift erzeugen"
#: g10/g10.c:164
msgid "encrypt data"
msgstr "Daten verschlüsseln"
#: g10/g10.c:165
msgid "encryption only with symmetric cipher"
msgstr "Daten nur symmetrisch verschlüsseln"
#: g10/g10.c:166
msgid "store only"
msgstr "Nur speichern"
#: g10/g10.c:167
msgid "decrypt data (default)"
msgstr "Daten entschlüsseln (Voreinstellung)"
#: g10/g10.c:168
msgid "verify a signature"
msgstr "Signatur prüfen"
#: g10/g10.c:170
msgid "list keys"
msgstr "Liste der Schlüssel"
#: g10/g10.c:171
msgid "list keys and signatures"
msgstr "Liste der Schlüssel und ihrer Signaturen"
#: g10/g10.c:172
msgid "check key signatures"
msgstr "Signaturen der Schlüssel prüfen"
#: g10/g10.c:173
msgid "list keys and fingerprints"
msgstr "Liste der Schlüssel und ihrer \"Fingerabdrücke\""
#: g10/g10.c:174
msgid "list secret keys"
msgstr "Liste der geheimen Schlüssel"
#: g10/g10.c:176
msgid "generate a new key pair"
msgstr "Ein neues Schlüsselpaar erzeugen"
#: g10/g10.c:178
msgid "remove key from the public keyring"
msgstr "Schlüssel entfernen"
#: g10/g10.c:180
msgid "sign or edit a key"
msgstr "Unterschreiben oder Bearbeiten eines Schlüssels"
#: g10/g10.c:181
msgid "generate a revocation certificate"
msgstr "Ein Schlüsselwiderruf-Zertifikat erzeugen"
#: g10/g10.c:183
msgid "export keys"
msgstr "Schlüssel exportieren"
#: g10/g10.c:185
msgid "import/merge keys"
msgstr "Schlüssel importieren/kombinieren"
#: g10/g10.c:187
msgid "list only the sequence of packets"
msgstr "Lediglich die Struktur der Datenpackete anzeigen"
#: g10/g10.c:190
msgid "export the ownertrust values"
msgstr "Exportieren der \"Owner trust\" Werte"
#: g10/g10.c:192
msgid "import ownertrust values"
msgstr "Importieren der \"Owner trust\" Werte"
#: g10/g10.c:194
msgid "|[NAMES]|update the trust database"
msgstr "|[NAMES]|Ändern der \"Trust\"-Datenbank"
#: g10/g10.c:196
msgid "|[NAMES]|check the trust database"
msgstr "|[NAMES]|Überprüfen der \"Trust\"-Datenbank"
#: g10/g10.c:197
msgid "fix a corrupted trust database"
msgstr "Reparieren einer beschädigten \"Trust\"-Datenbank"
#: g10/g10.c:198
msgid "De-Armor a file or stdin"
msgstr "Datei oder stdin von der ASCII-Hülle befreien"
#: g10/g10.c:199
msgid "En-Armor a file or stdin"
msgstr "Datei oder stdin in eine ASCII-Hülle einpacken"
#: g10/g10.c:200
msgid "|algo [files]|print message digests"
msgstr "|algo [files]|Message-Digests für die Dateien ausgeben"
#: g10/g10.c:201
msgid "print all message digests"
msgstr "Message-Digests für die Eingabedaten ausgeben"
#: g10/g10.c:208
msgid ""
"@\n"
"Options:\n"
" "
msgstr ""
"@\n"
"Optionen:\n"
" "
#: g10/g10.c:210
msgid "create ascii armored output"
msgstr "Ausgabe mit ASCII-Hülle versehen"
#: g10/g10.c:212
msgid "use this user-id to sign or decrypt"
msgstr "Mit dieser User-ID signieren"
#: g10/g10.c:213
msgid "use this user-id for encryption"
msgstr "Verschlüsseln für diese User-ID"
#: g10/g10.c:214
msgid "|N|set compress level N (0 disables)"
msgstr "Kompressionsstufe auf N setzen (0 = keine Kompr.)"
#: g10/g10.c:216
msgid "use canonical text mode"
msgstr "Textmodus benutzen"
#: g10/g10.c:218
msgid "use as output file"
msgstr "Als Ausgabedatei benutzen"
#: g10/g10.c:219
msgid "verbose"
msgstr "Detaillierte Informationen"
#: g10/g10.c:220
msgid "be somewhat more quiet"
msgstr "Etwas weniger Infos"
#: g10/g10.c:221
msgid "force v3 signatures"
msgstr "v3 Signaturen erzwingen"
#. { oDryRun, "dry-run", 0, N_("do not make any changes") },
#: g10/g10.c:223
msgid "batch mode: never ask"
msgstr "Stapelmodus: Keine Abfragen"
#: g10/g10.c:224
msgid "assume yes on most questions"
msgstr "\"Ja\" als Standardantwort annehmen"
#: g10/g10.c:225
msgid "assume no on most questions"
msgstr "\"Nein\" als Standardantwort annehmen"
#: g10/g10.c:226
msgid "add this keyring to the list of keyrings"
msgstr "Als öffentlichen Schlüsselbund mitbenutzen"
#: g10/g10.c:227
msgid "add this secret keyring to the list"
msgstr "Als geheimen Schlüsselbund mitbenutzen"
#: g10/g10.c:228
msgid "|NAME|use NAME as default secret key"
msgstr "|NAME|NAME als voreingestellten Schlüssel benutzen"
#: g10/g10.c:229
msgid "|NAME|set terminal charset to NAME"
msgstr "|NAME|Terminalzeichensatz NAME benutzen"
#: g10/g10.c:230
msgid "read options from file"
msgstr "Optionen aus der Datei lesen"
#: g10/g10.c:232
msgid "set debugging flags"
msgstr "Debug-Flags einschalten"
#: g10/g10.c:233
msgid "enable full debugging"
msgstr "Alle Debug-Flags einschalten"
#: g10/g10.c:234
msgid "|FD|write status info to this FD"
msgstr "|FD|Statusinfo auf FD (Dateihandle) ausgeben"
#: g10/g10.c:235
msgid "do not write comment packets"
msgstr "Keine Kommentarpakete schreiben"
#: g10/g10.c:236
msgid "(default is 1)"
msgstr "Benötigte Vollvertrauen (Voreinstellung 1)"
#: g10/g10.c:237
msgid "(default is 3)"
msgstr "Benötigte Teilvertrauen (Voreinstellung 3)"
#: g10/g10.c:239
msgid "|KEYID|ulimately trust this key"
msgstr "|KEYID|Diesem Schlüssel uneingeschränkt vertrauen"
#: g10/g10.c:240
msgid "|FILE|load extension module FILE"
msgstr "|FILE|Erweiterungsmodul DATEI laden"
#: g10/g10.c:241
msgid "emulate the mode described in RFC1991"
msgstr "Den in RFC1991 beschriebenen Modus nachahmen"
#: g10/g10.c:242
msgid "|N|use passphrase mode N"
msgstr "|N|Verwenden des Mantra-Modus N"
#: g10/g10.c:244
msgid "|NAME|use message digest algorithm NAME for passphrases"
msgstr "|NAME|Das Hashverfahren NAME für Mantras benutzen"
#: g10/g10.c:246
msgid "|NAME|use cipher algorithm NAME for passphrases"
msgstr "|NAME|Das Verschlü.verfahren NAME für Mantras benutzen"
#: g10/g10.c:248
msgid "|NAME|use cipher algorithm NAME"
msgstr "|NAME|Das Verschlü.verfahren NAME benutzen"
#: g10/g10.c:249
msgid "|NAME|use message digest algorithm NAME"
msgstr "|NAME|Das Hashverfahren NAME benutzen"
#: g10/g10.c:250
msgid "|N|use compress algorithm N"
msgstr "|N|Die Komprimierverfahren N benutzen"
#: g10/g10.c:251
msgid "throw keyid field of encrypted packets"
msgstr "entferne die AbsenderI-ID verschlüsselter Pakete"
#: g10/g10.c:259
msgid ""
"@\n"
"Examples:\n"
"\n"
" -se -r Bob [file] sign and encrypt for user Bob\n"
" --clearsign [file] make a clear text signature\n"
" --detach-sign [file] make a detached signature\n"
" --list-keys [names] show keys\n"
" --fingerprint [names] show fingerprints\n"
msgstr ""
"@\n"
"Beispiele:\n"
"\n"
" -se -r Bob [Datei] Signieren und verschlüsseln für Benutzer Bob\n"
" --clearsign [Datei] Eine Klartextsignatur erzeugen\n"
" --detach-sign [Datei] Eine abgetrennte Signatur erzeugen\n"
" --list-keys [Namen] Schlüssel anzeigen\n"
" --fingerprint [Namen] \"Fingerabdrücke\" anzeigen\n"
#: g10/g10.c:337
msgid "Please report bugs to <gnupg-bugs@gnu.org>.\n"
msgstr "Berichte über Wanzen (Programmfehler) bitte an <gnupg-bugs@gnu.org>.\n"
#: g10/g10.c:342
msgid "Usage: gpgm [options] [files] (-h for help)"
msgstr "Syntax: gpgm [Optionen] [Dateien] (-h für Hilfe)"
#: g10/g10.c:344
msgid "Usage: gpg [options] [files] (-h for help)"
msgstr "Aufruf: gpg [Optionen] [Dateien] (-h für Hilfe)"
#: g10/g10.c:349
msgid ""
"Syntax: gpgm [options] [files]\n"
"GnuPG maintenance utility\n"
msgstr ""
"Syntax: gpgm [options] [files]\n"
"GnuPG Wartungs-Hilfsprogramm\n"
#: g10/g10.c:352
msgid ""
"Syntax: gpg [options] [files]\n"
"sign, check, encrypt or decrypt\n"
"default operation depends on the input data\n"
msgstr ""
"Aufruf: gpg [Optionen] [Dateien]\n"
"Signieren, prüfen, verschlüsseln, entschlüsseln\n"
"Die voreingestellte Operation ist abhängig von den Eingabedaten\n"
#: g10/g10.c:358
msgid ""
"\n"
"Supported algorithms:\n"
msgstr ""
"\n"
"Unterstützte Verfahren:\n"
#: g10/g10.c:433
msgid "usage: gpgm [options] "
msgstr "Aufruf: gpgm [Optionen] "
#: g10/g10.c:435
msgid "usage: gpg [options] "
msgstr "Aufruf: gpg [Optionen] "
#: g10/g10.c:476
msgid "conflicting commands\n"
msgstr "Widersprüchliche Kommandos\n"
#: g10/g10.c:614
#, c-format
msgid "NOTE: no default option file '%s'\n"
msgstr "Hinweis: Keine voreingestellte Optionendatei '%s' vorhanden\n"
#: g10/g10.c:618
#, c-format
msgid "option file '%s': %s\n"
msgstr "Optionendatei '%s': %s\n"
#: g10/g10.c:625
#, c-format
msgid "reading options from '%s'\n"
msgstr "Optionen werden aus '%s' gelesen\n"
#: g10/g10.c:773
#, c-format
msgid "%s is not a valid character set\n"
msgstr "%s ist kein gültiger Zeichensatz.\n"
#: g10/g10.c:807 g10/g10.c:819
msgid "selected cipher algorithm is invalid\n"
msgstr "Das ausgewählte Verschlüsslungsverfahren ist ungültig\n"
#: g10/g10.c:813 g10/g10.c:825
msgid "selected digest algorithm is invalid\n"
msgstr "Das ausgewählte Hashverfahren ist ungültig\n"
#: g10/g10.c:828
#, c-format
msgid "compress algorithm must be in range %d..%d\n"
msgstr "Das Komprimierverfahren muß im Bereich %d bis %d liegen\n"
#: g10/g10.c:830
msgid "completes-needed must be greater than 0\n"
msgstr "completes-needed müssen größer als 0 sein\n"
#: g10/g10.c:832
msgid "marginals-needed must be greater than 1\n"
msgstr "marginals-needed müssen größer als 1 sein\n"
#: g10/g10.c:834
msgid "max-cert-depth must be in range 1 to 255\n"
msgstr "max-cert-depth muß im Bereich 1 bis 255 liegen\n"
#: g10/g10.c:837
msgid "NOTE: simple S2K mode (0) is strongly discouraged\n"
msgstr "Hinweis: Vom \"simple S2K\"-Modus (0) ist strikt abzuraten\n"
#: g10/g10.c:841
msgid "invalid S2K mode; must be 0, 1 or 3\n"
msgstr "ungültiger \"simple S2K\"-Modus; Wert muß 0, 1 oder 3 sein\n"
#: g10/g10.c:924
#, c-format
msgid "failed to initialize the TrustDB: %s\n"
msgstr "Die Trust-DB kann nicht initialisiert werden: %s\n"
#: g10/g10.c:930
msgid "--store [filename]"
msgstr "--store [Dateiname]"
#: g10/g10.c:938
msgid "--symmetric [filename]"
msgstr "--symmetric [Dateiname]"
#: g10/g10.c:946
msgid "--encrypt [filename]"
msgstr "--encrypt [Dateiname]"
#: g10/g10.c:959
msgid "--sign [filename]"
msgstr "--sign [Dateiname]"
#: g10/g10.c:972
msgid "--sign --encrypt [filename]"
msgstr "--sign --encrypt [Dateiname]"
#: g10/g10.c:986
msgid "--clearsign [filename]"
msgstr "--clearsign [Dateiname]"
#: g10/g10.c:998
msgid "--decrypt [filename]"
msgstr "--decrypt [Dateiname]"
#: g10/g10.c:1007
msgid "--edit-key username [commands]"
msgstr "--edit-key Username [Befehle]"
#: g10/g10.c:1023
msgid "--delete-secret-key username"
msgstr "--delete-secret-key Username"
#: g10/g10.c:1026
msgid "--delete-key username"
msgstr "--delete-key Benutzername"
#: g10/encode.c:216 g10/g10.c:1049 g10/sign.c:301
#, c-format
msgid "can't open %s: %s\n"
msgstr "'%s' kann nicht geöffnet werden: %s\n"
#: g10/g10.c:1060
msgid "-k[v][v][v][c] [userid] [keyring]"
msgstr "-k[v][v][v][c] [Benutzername] [Keyring]"
#: g10/g10.c:1116
#, c-format
msgid "dearmoring failed: %s\n"
msgstr "Entfernen der ASCII-Hülle ist fehlgeschlagen: %s\n"
#: g10/g10.c:1124
#, c-format
msgid "enarmoring failed: %s\n"
msgstr "Anbringen der ASCII-Hülle ist fehlgeschlagen: %s\n"
#: g10/g10.c:1190
#, c-format
msgid "invalid hash algorithm '%s'\n"
msgstr "Ungültiges Hashverfahren '%s'\n"
#: g10/g10.c:1269
msgid "[filename]"
msgstr "[Dateiname]"
#: g10/g10.c:1273
msgid "Go ahead and type your message ...\n"
msgstr "Auf geht's - Botschaft eintippen ...\n"
#: g10/decrypt.c:59 g10/g10.c:1276 g10/verify.c:66
#, c-format
msgid "can't open '%s'\n"
msgstr "'%s' kann nicht geöffnet werden\n"
#: g10/g10.c:1325
msgid ""
"RSA keys are deprecated; please consider creating a new key and use this key "
"in the future\n"
msgstr ""
"RSA Schlüssel sind nicht erwünscht; bitte denken Sie darüber nach, einen\n"
"neuen Schlüssel zu erzeugen und diesen in Zukunft zu benutzen\n"
#: g10/armor.c:344 g10/armor.c:391
msgid "armor header: "
msgstr "ASCII-Hülle: "
#: g10/armor.c:355
msgid "invalid clearsig header\n"
msgstr "Ungültige Klartextsignatur-Einleitung\n"
#: g10/armor.c:382
msgid "invalid armor header: "
msgstr "Ungültige ASCII-Hülle"
#: g10/armor.c:460
#, c-format
msgid "armor: %s\n"
msgstr "ASCII-Hülle: %s\n"
#: g10/armor.c:533
msgid "invalid dash escaped line: "
msgstr "Ungültige mit Bindestrich \"escapte\" Zeile: "
#: g10/armor.c:602
msgid "invalid clear text header: "
msgstr "ungültige Klartexteinleitung"
#: g10/armor.c:845
#, c-format
msgid "invalid radix64 character %02x skipped\n"
msgstr "Ungültiges \"radix64\" Zeichen %02x ignoriert\n"
#: g10/armor.c:878
msgid "premature eof (no CRC)\n"
msgstr "vorzeitiges Dateiende (keine Prüfsumme)\n"
#: g10/armor.c:897
msgid "premature eof (in CRC)\n"
msgstr "vorzeitiges Dateiende (innerhalb der Prüfsumme)\n"
#: g10/armor.c:901
msgid "malformed CRC\n"
msgstr "Falsch aufgebaute Prüfsumme\n"
#: g10/armor.c:905
#, c-format
msgid "CRC error; %06lx - %06lx\n"
msgstr "Prüfsummenfehler; %06lx - %06lx\n"
#: g10/armor.c:924
msgid "premature eof (in Trailer)\n"
msgstr "vorzeitiges Dateiende (im Nachsatz)\n"
#: g10/armor.c:928
msgid "error in trailer line\n"
msgstr "Fehler in der Nachsatzzeile\n"
#: g10/armor.c:1182
msgid "no valid RFC1991 or OpenPGP data found.\n"
msgstr "Keine gültigen RFC1991- oder OpenPGP-Daten gefunden.\n"
#: g10/pkclist.c:121
#, c-format
msgid ""
"No trust value assigned to %lu:\n"
"%4u%c/%08lX %s \""
msgstr ""
"Es ist kein \"Owner trust\" für %lu definiert:\n"
"%4u%c/%08lX %s \""
#: g10/pkclist.c:131
msgid ""
"Please decide how far you trust this user to correctly\n"
"verify other users' keys (by looking at passports,\n"
"checking fingerprints from different sources...)?\n"
"\n"
" 1 = Don't know\n"
" 2 = I do NOT trust\n"
" 3 = I trust marginally\n"
" 4 = I trust fully\n"
" s = please show me more information\n"
msgstr ""
"Bitte entscheiden Sie, in wieweit Sie diesem User zutrauen,\n"
"den Schlüssel eines anderen Users korrekt zu prüfen (Vergleich mit\n"
"Lictbildausweisen, Vergleich der Fingerabdrücke aus unterschiedlichen\n"
"Quellen ...)?\n"
"\n"
" 1 = Weiß nicht so recht\n"
" 2 = Neeh, dem traue ich das nicht zu\n"
" 3 = Ich vertraue ihm normalerweise\n"
" 4 = Ich vertraue ihm vollständig\n"
" s = Bitte weitere Information anzeigen\n"
#: g10/pkclist.c:140
msgid " m = back to the main menu\n"
msgstr " m = Zurück zum Menü\n"
# valid user replies (not including 1..4)
#. a string with valid answers
#: g10/pkclist.c:145
msgid "sSmM"
msgstr "sSmM"
#: g10/pkclist.c:149
msgid "Your decision? "
msgstr "Ihre Auswahl? "
#: g10/pkclist.c:169
msgid "Certificates leading to an ultimately trusted key:\n"
msgstr "Zertifikate führen zu einem letztlich vertrauenswürdigen Schlüssel:\n"
#: g10/pkclist.c:197
msgid ""
"Could not find a valid trust path to the key. Let's see whether we\n"
"can assign some missing owner trust values.\n"
"\n"
msgstr ""
"Für diesen Schlüssel konnte kein gültiger \"Trust Path\" gefunden werden.\n"
"Mal sehen, ob wir sonst irgendwie ein paar fehlende \"Owner trust\" Werte \n"
"ermitteln können.\n"
"\n"
#: g10/pkclist.c:219
msgid ""
"No path leading to one of our keys found.\n"
"\n"
msgstr ""
"Kein Pfad führt zu einen unserer Schlüsseln.\n"
"\n"
#: g10/pkclist.c:221
msgid ""
"No certificates with undefined trust found.\n"
"\n"
msgstr ""
"Keine Zertifikate mit undefinierten Vertrauen gefunden.\n"
"\n"
#: g10/pkclist.c:223
msgid ""
"No trust values changed.\n"
"\n"
msgstr ""
"Keine \"trust\" Werte geändert.\n"
"\n"
#: g10/pkclist.c:238
#, c-format
msgid "key %08lX: key has been revoked!\n"
msgstr "Schlüssel %08lX: Schlüssel wurde widerrufen\n"
#: g10/pkclist.c:244 g10/pkclist.c:335
msgid "Use this key anyway? "
msgstr "Diesen Schlüssel trotzdem benutzen?"
#: g10/pkclist.c:266
#, c-format
msgid "%08lX: key has expired\n"
msgstr "%08lX: Schlüssel ist verfallen!\n"
#: g10/pkclist.c:272
#, c-format
msgid "%08lX: no info to calculate a trust probability\n"
msgstr ""
"%08lX: Keine Infos zur Berechnung der Vertrauenswahrscheinlichkeit "
"vorgefunden\n"
#: g10/pkclist.c:288
#, c-format
msgid "%08lX: We do NOT trust this key\n"
msgstr "%08lX: Wir haben KEIN Vertrauen zu diesem Schlüssel!\n"
#: g10/pkclist.c:294
#, c-format
msgid ""
"%08lX: It is not sure that this key really belongs to the owner\n"
"but it is accepted anyway\n"
msgstr ""
"%08lX: Es ist nicht sicher, daß dieser Schlüssel wirklich dem vorgeblichen\n"
"Besitzer gehört, aber er wird trotzdem akzeptiert\n"
#: g10/pkclist.c:300
msgid "This key probably belongs to the owner\n"
msgstr ""
"Dieser Schlüssel gehört uns (alldieweil wir den geheimen Schlüssel dazu "
"haben)\n"
#: g10/pkclist.c:305
msgid "This key belongs to us\n"
msgstr ""
"Dieser Schlüssel gehört uns (alldieweil wir den geheimen Schlüssel dazu "
"haben)\n"
#: g10/pkclist.c:330
msgid ""
"It is NOT certain that the key belongs to its owner.\n"
"If you *really* know what you are doing, you may answer\n"
"the next question with yes\n"
"\n"
msgstr ""
"Es ist NICHT sicher, daß der Schlüssel dem vorgeblichen Besitzer gehört.\n"
"Wenn Sie *wirklich* wissen, was Sie tun, können Sie die nächste\n"
"Frage mit ja beantworten\n"
#: g10/pkclist.c:339
msgid "WARNING: Using untrusted key!\n"
msgstr "WARNUNG: Ein Schlüssel ohne gesichertes Vertrauen wird benutzt!\n"
#: g10/pkclist.c:375
msgid "WARNING: This key has been revoked by its owner!\n"
msgstr "WARNUNG: Dieser Schlüssel wurde von seinem Besitzer widerrufen!\n"
#: g10/pkclist.c:376
msgid " This could mean that the signature is forgery.\n"
msgstr " Das könnte bedeuten, daß die Signatur gefälscht ist.\n"
#: g10/pkclist.c:397
msgid "Note: This key has expired!\n"
msgstr "Hinweis: Dieser Schlüssel ist verfallen!\n"
#: g10/pkclist.c:404
msgid "WARNING: This key is not certified with a trusted signature!\n"
msgstr "WARNUNG: Dieser Schlüssel trägt keine vertrauenswürdige Signatur!\n"
#: g10/pkclist.c:406
msgid ""
" There is no indication that the signature belongs to the owner.\n"
msgstr ""
" Es gibt keinen Hinweis, daß die Signatur wirklich dem vorgeblichen "
"Besitzer gehört.\n"
#: g10/pkclist.c:421
msgid "WARNING: We do NOT trust this key!\n"
msgstr "WARNUNG: Wir haben KEIN Vertrauen zu diesem Schlüssel!\n"
#: g10/pkclist.c:422
msgid " The signature is probably a FORGERY.\n"
msgstr " Die Signatur ist wahrscheinlich eine FÄLSCHUNG.\n"
#: g10/pkclist.c:429
msgid ""
"WARNING: This key is not certified with sufficiently trusted signatures!\n"
msgstr ""
"WARNUNG: Dieser Schlüssel ist nicht durch hinreichend vertrauenswürdige "
"Signaturen zertifiziert!\n"
#: g10/pkclist.c:432
msgid " It is not certain that the signature belongs to the owner.\n"
msgstr ""
" Es ist nicht sicher, daß die Signatur wirklich dem vorgeblichen "
"Besitzer gehört.\n"
#: g10/pkclist.c:477
msgid ""
"You did not specify a user ID. (you may use \"-r\")\n"
"\n"
msgstr ""
"Sie gaben keine User-ID angegeben (Benutzen Sie die Option \"-r\").\n"
"\n"
#: g10/pkclist.c:482
msgid "Enter the user ID: "
msgstr "Geben Sie die User-ID ein: "
#: g10/pkclist.c:493
msgid "No such user ID.\n"
msgstr "Keine solche User-ID vorhanden.\n"
#: g10/pkclist.c:527 g10/pkclist.c:554
#, c-format
msgid "%s: skipped: %s\n"
msgstr "%s: übersprungen: %s\n"
#: g10/pkclist.c:535
#, c-format
msgid "%s: error checking key: %s\n"
msgstr "%s: Fehler beim Prüfen des Schlüssels: %s\n"
#: g10/pkclist.c:561
msgid "no valid addressees\n"
msgstr "Keine gültigen Adressaten\n"
#: g10/keygen.c:124
msgid "writing self signature\n"
msgstr "Die Eigenbeglaubigung wird geschrieben\n"
#: g10/keygen.c:162
msgid "writing key binding signature\n"
msgstr "Schreiben der \"key-binding\" Signatur\n"
#: g10/keygen.c:388
msgid "Please select what kind of key you want:\n"
msgstr "Bitte wählen Sie, welche Art von Schlüssel Sie möchten:\n"
#: g10/keygen.c:390
#, c-format
msgid " (%d) DSA and ElGamal (default)\n"
msgstr " (%d) DSA und ElGamal (voreingestellt)\n"
#: g10/keygen.c:391
#, c-format
msgid " (%d) ElGamal (sign and encrypt)\n"
msgstr " (%d) ElGamal (signieren/beglaubigen und verschlüsseln)\n"
#: g10/keygen.c:393
#, c-format
msgid " (%d) ElGamal (encrypt only)\n"
msgstr " (%d) ElGamal (nur verschlüsseln)\n"
#: g10/keygen.c:394
#, c-format
msgid " (%d) DSA (sign only)\n"
msgstr " (%d) DSA (nur signieren/beglaubigen)\n"
#: g10/keygen.c:395
#, c-format
msgid " (%d) ElGamal in a v3 packet\n"
msgstr " (%d) ElGamal in einem v3-Paket\n"
#: g10/keygen.c:399
msgid "Your selection? "
msgstr "Ihre Auswahl? "
#: g10/keygen.c:425
msgid "Invalid selection.\n"
msgstr "Ungültige Auswahl.\n"
#: g10/keygen.c:437
#, c-format
msgid ""
"About to generate a new %s keypair.\n"
" minimum keysize is 768 bits\n"
" default keysize is 1024 bits\n"
" highest suggested keysize is 2048 bits\n"
msgstr ""
"Es wird ein neues %s Schlüsselpaar erzeugt.\n"
" kleinste Schlüssellänge ist 768 Bit\n"
" standard Schlüssellänge ist 1024 Bit\n"
" größte sinnvolle Schlüssellänge ist 2048 Bit\n"
#: g10/keygen.c:444
msgid "What keysize do you want? (1024) "
msgstr "Welche Schlüssellänge wünschen Sie? (1024) "
#: g10/keygen.c:449
msgid "DSA only allows keysizes from 512 to 1024\n"
msgstr "DSA erlaubt nur Schlüssellängen von 512 bis 1024\n"
#: g10/keygen.c:451
msgid "keysize too small; 768 is smallest value allowed.\n"
msgstr "zu kurz; 768 ist die kleinste mögliche Schlüssellänge.\n"
#: g10/keygen.c:454
msgid ""
"Keysizes larger than 2048 are not suggested because\n"
"computations take REALLY long!\n"
msgstr ""
"Schlüssellängen größer als 2048 werden nicht empfohlen, da die\n"
"Berechnungen dann WIRKLICH lange brauchen!\n"
#: g10/keygen.c:457
msgid "Are you sure that you want this keysize? "
msgstr "Sind Sie sicher, daß Sie diese Schlüssellänge wünschen? "
#: g10/keygen.c:458
msgid ""
"Okay, but keep in mind that your monitor and keyboard radiation is also very "
"vulnerable to attacks!\n"
msgstr ""
"Gut, aber bitte denken Sie auch daran, daß Monitor und Tastatur Daten "
"abstrahlen und diese leicht mitgelesen werden können.\n"
#: g10/keygen.c:466
msgid "Do you really need such a large keysize? "
msgstr "Brauchen Sie wirklich einen derartig langen Schlüssel? "
#: g10/keygen.c:472
#, c-format
msgid "Requested keysize is %u bits\n"
msgstr "Die verlangte Schlüssellänge beträgt %u Bit\n"
#: g10/keygen.c:475 g10/keygen.c:479
#, c-format
msgid "rounded up to %u bits\n"
msgstr "aufgerundet auf %u Bit\n"
#: g10/keygen.c:492
msgid ""
"Please specify how long the key should be valid.\n"
" 0 = key does not expire\n"
" <n> = key expires in n days\n"
" <n>w = key expires in n weeks\n"
" <n>m = key expires in n months\n"
" <n>y = key expires in n years\n"
msgstr ""
"Bitte wählen Sie, wie lange der Schlüssel gültig bleiben soll.\n"
" 0 = Schlüssel verfällt nie\n"
" <n> = Schlüssel verfällt nach n Tagen\n"
" <n>w = Schlüssel verfällt nach n Wochen\n"
" <n>m = Schlüssel verfällt nach n Monaten\n"
" <n>y = Schlüssel verfällt nach n Jahren\n"
#: g10/keygen.c:507
msgid "Key is valid for? (0) "
msgstr "Der Schlüssel bleibt wie lange gültig? (0) "
#: g10/keygen.c:518
msgid "invalid value\n"
msgstr "Ungültiger Wert.\n"
#: g10/keygen.c:523
msgid "Key does not expire at all\n"
msgstr "Der Schlüssel verfällt nie.\n"
#. print the date when the key expires
#: g10/keygen.c:529
#, c-format
msgid "Key expires at %s\n"
msgstr "Der Schlüssel verfällt am %s\n"
#: g10/keygen.c:535
msgid "Is this correct (y/n)? "
msgstr "Ist dies richtig? (j/n) "
#: g10/keygen.c:577
msgid ""
"\n"
"You need a User-ID to identify your key; the software constructs the user "
"id\n"
"from Real Name, Comment and Email Address in this form:\n"
" \"Heinrich Heine (Der Dichter) <heinrichh@duesseldorf.de>\"\n"
"\n"
msgstr ""
"\n"
"Sie benötigen eine User-ID, um Ihren Schlüssel eindeutig zu machen; das\n"
"Programm baut diese User-ID aus Ihrem echten Namen, einem Kommentar und\n"
"Ihrer E-Mail-Adresse in dieser Form auf:\n"
" \"Heinrich Heine (Der Dichter) <heinrichh@duesseldorf.de>\"\n"
"\n"
#: g10/keygen.c:588
msgid "Real name: "
msgstr "Ihr Name (\"Vorname Nachname\"): "
#: g10/keygen.c:592
msgid "Invalid character in name\n"
msgstr "Ungültiges Zeichen im Namen\n"
#: g10/keygen.c:594
msgid "Name may not start with a digit\n"
msgstr "Der Name darf nicht mit einer Ziffer beginnen.\n"
#: g10/keygen.c:596
msgid "Name must be at least 5 characters long\n"
msgstr "Der Name muß min. 5 Zeichen lang sein.\n"
#: g10/keygen.c:604
msgid "Email address: "
msgstr "E-Mail-Adresse: "
#: g10/keygen.c:616
msgid "Not a valid email address\n"
msgstr "Diese E-Mail-Adresse ist ungültig\n"
#: g10/keygen.c:624
msgid "Comment: "
msgstr "Kommentar: "
#: g10/keygen.c:630
msgid "Invalid character in comment\n"
msgstr "Ungültiges Zeichen im Kommentar.\n"
#: g10/keygen.c:650
#, c-format
msgid ""
"You selected this USER-ID:\n"
" \"%s\"\n"
"\n"
msgstr ""
"Sie haben diese User-ID gewählt:\n"
" \"%s\"\n"
"\n"
#: g10/keygen.c:653
msgid "NnCcEeOoQq"
msgstr "NnKkEeFfBb"
#: g10/keygen.c:663
msgid "Change (N)ame, (C)omment, (E)mail or (O)kay/(Q)uit? "
msgstr "Ändern: (N)ame, (K)ommentar, (E)-Mail oder (F)ertig/(B)eenden? "
#: g10/keygen.c:715
msgid ""
"You need a Passphrase to protect your secret key.\n"
"\n"
msgstr ""
"Sie benötigen ein Mantra, um den geheimen Schlüssel zu schützen.\n"
"\n"
#: g10/keyedit.c:389 g10/keygen.c:723
msgid "passphrase not correctly repeated; try again.\n"
msgstr "Mantra wurde nicht richtig wiederholt; noch einmal versuchen.\n"
#: g10/keygen.c:729
msgid ""
"You don't want a passphrase - this is probably a *bad* idea!\n"
"I will do it anyway. You can change your passphrase at any time,\n"
"using this program with the option \"--edit-key\".\n"
"\n"
msgstr ""
"Sie möchten kein Mantra - Dies ist *nicht* zu empfehlen!\n"
"Es ist trotzdem möglich. Sie können Ihr Mantra jederzeit\n"
"ändern, indem sie dieses Programm mit dem Kommando \"--edit-key\"\n"
"aufrufen.\n"
"\n"
#: g10/keygen.c:750
msgid ""
"We need to generate a lot of random bytes. It is a good idea to perform\n"
"some other action (work in another window, move the mouse, utilize the\n"
"network and the disks) during the prime generation; this gives the random\n"
"number generator a better chance to gain enough entropy.\n"
msgstr ""
"Wir müßen eine ganze Menge Zufallszahlen erzeugen. Sie können dies\n"
"unterstützen, indem Sie z.B. in einem anderen Fenster/Konsole irgendetwas\n"
"tippen oder irgendwelche anderen Programme benutzen.\n"
#: g10/keygen.c:820
msgid "Key generation can only be used in interactive mode\n"
msgstr ""
"Die Schlüsselerzeugung kann nur im interaktiven Modus benutzt werden.\n"
#: g10/keygen.c:828
msgid "DSA keypair will have 1024 bits.\n"
msgstr "Der DSA Schlüssel wird 1024 Bits haben.\n"
#: g10/keygen.c:834
msgid "Key generation cancelled.\n"
msgstr "Schlüsselerzeugung abgebrochen.\n"
#: g10/keygen.c:844
#, c-format
msgid "writing public certificate to '%s'\n"
msgstr "schreiben des öffentlichen Schlüssels nach '%s'\n"
#: g10/keygen.c:845
#, c-format
msgid "writing secret certificate to '%s'\n"
msgstr "schreiben des geheimen Schlüssels nach '%s'\n"
#: g10/keygen.c:922
msgid "public and secret key created and signed.\n"
msgstr "Öffentlichen und geheimen Schlüssel erzeugt und signiert.\n"
#: g10/keygen.c:924
msgid ""
"Note that this key cannot be used for encryption. You may want to use\n"
"the command \"--add-key\" to generate a secondary key for this purpose.\n"
msgstr ""
"Bitte beachten Sie, daß dieser Schlüssel nicht zum Verschlüsseln benutzt\n"
"werden kann. Sie können aber mit dem Kommando \"--add-key\" einen\n"
"Zweitschlüssel zu diesem Schlüssel hinzufügen.\n"
#: g10/keygen.c:938 g10/keygen.c:1023
#, c-format
msgid "Key generation failed: %s\n"
msgstr "Schlüsselerzeugung fehlgeschlagen: %s\n"
#: g10/keygen.c:1001
msgid "Really create? "
msgstr "Wirklich erzeugen? "
#: g10/encode.c:88 g10/openfile.c:81 g10/openfile.c:158 g10/tdbio.c:445
#: g10/tdbio.c:504
#, c-format
msgid "%s: can't open: %s\n"
msgstr "%s: kann nicht geöffnet werden: %s\n"
#: g10/encode.c:107
#, c-format
msgid "error creating passphrase: %s\n"
msgstr "Fehler beim Erzeugen des Mantras: %s\n"
#: g10/encode.c:155 g10/encode.c:269
#, c-format
msgid "%s: WARNING: empty file\n"
msgstr "%s: WARNUNG: Leere Datei\n"
#: g10/encode.c:222
#, c-format
msgid "reading from '%s'\n"
msgstr "Lesen von '%s'\n"
#: g10/encode.c:397
#, c-format
msgid "%s encrypted for: %s\n"
msgstr "%s verschlüsselt für: %s\n"
#: g10/export.c:162
msgid "WARNING: nothing exported\n"
msgstr "WARNUNG: Nichts exportiert\n"
#: g10/getkey.c:164
msgid "too many entries in pk cache - disabled\n"
msgstr "zu viele Einträge im pk-Lager - abgeschaltet\n"
#: g10/getkey.c:263
msgid "too many entries in unk cache - disabled\n"
msgstr "zu viele Einträge im unk-Lager - abgeschaltet\n"
#: g10/getkey.c:989
#, c-format
msgid "using secondary key %08lX instead of primary key %08lX\n"
msgstr ""
"der Zweitschlüssel %08lX wird anstelle des Hauptschlüssels %08lX verwendet\n"
#: g10/import.c:129 g10/trustdb.c:1166
#, c-format
msgid "can't open file: %s\n"
msgstr "Kann die Datei nicht öffnen: %s\n"
#: g10/import.c:145
#, c-format
msgid "skipping block of type %d\n"
msgstr "überspringe den Block vom Typ %d\n"
#: g10/import.c:152 g10/trustdb.c:1425 g10/trustdb.c:1494
#, c-format
msgid "%lu keys so far processed\n"
msgstr "%lu Schlüssel bislang bearbeitet\n"
#: g10/import.c:157 g10/trustdb.c:1242
#, c-format
msgid "read error: %s\n"
msgstr "Lesefehler: %s\n"
#: g10/import.c:159
#, c-format
msgid "Total number processed: %lu\n"
msgstr "Anzahl insgesamt bearbeiteter Schlüssel: %lu\n"
#: g10/import.c:161
#, c-format
msgid " w/o user IDs: %lu\n"
msgstr " ohne User-ID: %lu\n"
#: g10/import.c:163
#, c-format
msgid " imported: %lu"
msgstr " importiert: %lu"
#: g10/import.c:169
#, c-format
msgid " unchanged: %lu\n"
msgstr " unverändert: %lu\n"
#: g10/import.c:171
#, c-format
msgid " new user IDs: %lu\n"
msgstr " neue User-IDs: %lu\n"
#: g10/import.c:173
#, c-format
msgid " new subkeys: %lu\n"
msgstr " neue Unterschlüssel: %lu\n"
#: g10/import.c:175
#, c-format
msgid " new signatures: %lu\n"
msgstr " neue Signaturen: %lu\n"
#: g10/import.c:177
#, c-format
msgid " new key revocations: %lu\n"
msgstr "neue Schlüsselwiderrufe: %lu\n"
#: g10/import.c:179
#, c-format
msgid " secret keys read: %lu\n"
msgstr " gelesene geheime Schl.: %lu\n"
#: g10/import.c:181
#, c-format
msgid " secret keys imported: %lu\n"
msgstr "geheime Schlüssel importiert: %lu\n"
#: g10/import.c:183
#, c-format
msgid " secret keys unchanged: %lu\n"
msgstr " unveränderte geh.Schl.: %lu\n"
#: g10/import.c:325 g10/import.c:517
#, c-format
msgid "key %08lX: no user id\n"
msgstr "Schlüssel %08lX: Keine User-ID\n"
#: g10/import.c:336
#, c-format
msgid "key %08lX: no valid user ids\n"
msgstr "Schlüssel %08lX: Keine gültigen User-IDs\n"
#: g10/import.c:338
msgid "this may be caused by a missing self-signature\n"
msgstr "dies könnte durch fehlende Eigenbeglaubigung verursacht worden sein\n"
#: g10/import.c:349 g10/import.c:585
#, c-format
msgid "key %08lX: public key not found: %s\n"
msgstr "Schlüssel %08lX: Öffentlicher Schlüssel nicht gefunden: %s\n"
#: g10/import.c:355
msgid "no default public keyring\n"
msgstr "Kein voreingestellter öffentlicher Schlüsselbund\n"
#: g10/import.c:359 g10/openfile.c:105 g10/sign.c:205 g10/sign.c:563
#, c-format
msgid "writing to '%s'\n"
msgstr "Schreiben nach '%s'\n"
#: g10/import.c:363 g10/import.c:423 g10/import.c:639
#, c-format
msgid "can't lock public keyring: %s\n"
msgstr "kann öffentlichen Schlüsselbund nicht sperren: %s\n"
#: g10/import.c:366
#, c-format
msgid "can't write to keyring: %s\n"
msgstr "kann Schlüsselbund nicht schreiben: %s\n"
#: g10/import.c:370
#, c-format
msgid "key %08lX: public key imported\n"
msgstr "Schlüssel %08lX: Öffentlicher Schlüssel importiert\n"
#: g10/import.c:383
#, c-format
msgid "key %08lX: doesn't match our copy\n"
msgstr "Schlüssel %08lX: Stimmt nicht mit unserer Kopie überein\n"
#: g10/import.c:396 g10/import.c:594
#, c-format
msgid "key %08lX: can't locate original keyblock: %s\n"
msgstr ""
"Schlüssel %08lX: der lokale originale Schlüsselblocks wurde nicht gefunden: %s\n"
#: g10/import.c:403 g10/import.c:601
#, c-format
msgid "key %08lX: can't read original keyblock: %s\n"
msgstr "Schlüssel %08lX: Lesefehler im lokalen originalen Schlüsselblocks: %s\n"
#: g10/import.c:420 g10/import.c:532 g10/import.c:636
msgid "writing keyblock\n"
msgstr "Schreiben des Schlüsselblocks\n"
#: g10/import.c:426 g10/import.c:642
#, c-format
msgid "can't write keyblock: %s\n"
msgstr "Der Schlüsselblock kann nicht geschrieben werden: %s\n"
#: g10/import.c:431
#, c-format
msgid "key %08lX: 1 new user-id\n"
msgstr "Schlüssel %08lX: 1 neue User-ID\n"
#: g10/import.c:434
#, c-format
msgid "key %08lX: %d new user-ids\n"
msgstr "Schlüssel %08lX: %d neue User-IDs\n"
#: g10/import.c:437
#, c-format
msgid "key %08lX: 1 new signature\n"
msgstr "Schlüssel %08lX: 1 neue Signatur\n"
#: g10/import.c:440
#, c-format
msgid "key %08lX: %d new signatures\n"
msgstr "Schlüssel %08lX: %d neue Signaturen\n"
#: g10/import.c:443
#, c-format
msgid "key %08lX: 1 new subkey\n"
msgstr "Schlüssel %08lX: 1 neuer Unterschlüssel\n"
#: g10/import.c:446
#, c-format
msgid "key %08lX: %d new subkeys\n"
msgstr "Schlüssel %08lX: %d neue Unterschlüssel\n"
#: g10/import.c:456
#, c-format
msgid "key %08lX: not changed\n"
msgstr "Schlüssel %08lX: Nicht geändert\n"
#: g10/import.c:535
#, c-format
msgid "can't lock secret keyring: %s\n"
msgstr "kann geheimen Schlüsselbund nicht sperren: %s\n"
#: g10/import.c:538
#, c-format
msgid "can't write keyring: %s\n"
msgstr "kann Schlüsselbund nicht schreiben: %s\n"
#. we are ready
#: g10/import.c:541
#, c-format
msgid "key %08lX: secret key imported\n"
msgstr "Schlüssel %08lX: Geheimer Schlüssel importiert\n"
#. we can't merge secret keys
#: g10/import.c:545
#, c-format
msgid "key %08lX: already in secret keyring\n"
msgstr "Schlüssel %08lX: Ist bereits im geheimen Schlüsselbund\n"
#: g10/import.c:550
#, c-format
msgid "key %08lX: secret key not found: %s\n"
msgstr "Schlüssel %08lX: geheimer Schlüssel nicht gefunden: %s\n"
#: g10/import.c:579
#, c-format
msgid "key %08lX: no public key - can't apply revocation certificate\n"
msgstr ""
"Schlüssel %08lX: Kein öffentlicher Schlüssel - der Schlüsselwiderruf kann "
"nicht angebracht werden\n"
#: g10/import.c:612
#, c-format
msgid "key %08lX: invalid revocation certificate: %s - rejected\n"
msgstr "Schlüssel %08lX: Ungültiges Widerrufzertifikat: %s - zurückgewiesen\n"
#: g10/import.c:646
#, c-format
msgid "key %08lX: revocation certificate imported\n"
msgstr "Schlüssel %08lX: Widerrufzertifikat importiert\n"
#: g10/import.c:677
#, c-format
msgid "key %08lX: no user-id for signature\n"
msgstr "Schlüssel %08lX: Keine User-ID für Signatur\n"
#: g10/import.c:684
#, c-format
msgid "key %08lX: unsupported public key algorithm\n"
msgstr "Schlüssel %08lX: Nicht unterstützetes Public-Key-Verfahren\n"
#: g10/import.c:685
#, c-format
msgid "key %08lX: invalid self-signature\n"
msgstr "Schlüssel %08lX: Ungültige Eigenbeglaubigung\n"
#: g10/import.c:714
#, c-format
msgid "key %08lX: skipped userid '"
msgstr "Schlüssel %08lX: übergehe User-ID '"
#: g10/import.c:737
#, c-format
msgid "key %08lX: revocation certificate at wrong place - skipped\n"
msgstr "Schlüssel %08lX: Widerrufzertifikat an falschem Platz - übergangen\n"
#: g10/import.c:745
#, c-format
msgid "key %08lX: invalid revocation certificate: %s - skipped\n"
msgstr "Schlüssel %08lX: Ungültiges Widerrufzertifikat: %s - übergangen\n"
#: g10/import.c:804
#, c-format
msgid "key %08lX: revocation certificate added\n"
msgstr "Schlüssel %08lX: Widerrufzertifikat hinzugefügt\n"
#: g10/import.c:918 g10/import.c:973
#, c-format
msgid "key %08lX: our copy has no self-signature\n"
msgstr "Schlüssel %08lX: Unsere Kopie hat keine Eigenbeglaubigung\n"
#: g10/keyedit.c:81
#, c-format
msgid "%s: user not found\n"
msgstr "%s: Benutzer nicht gefunden\n"
#: g10/keyedit.c:164
msgid "[self-signature]"
msgstr "[Eigenbeglaubigung]"
#: g10/keyedit.c:182
msgid "1 bad signature\n"
msgstr "%d schlechte Signaturen\n"
#: g10/keyedit.c:184
#, c-format
msgid "%d bad signatures\n"
msgstr "%d falsche Beglaubigungen\n"
#: g10/keyedit.c:186
msgid "1 signature not checked due to a missing key\n"
msgstr "1 Beglaubigung wegen fehlendem Schlüssel nicht geprüft\n"
#: g10/keyedit.c:188
#, c-format
msgid "%d signatures not checked due to missing keys\n"
msgstr "%d Beglaubigungen wegen fehlenden Schlüsseln nicht geprüft\n"
#: g10/keyedit.c:190
msgid "1 signature not checked due to an error\n"
msgstr "1 Beglaubigung aufgrund von Fehler nicht geprüft\n"
#: g10/keyedit.c:192
#, c-format
msgid "%d signatures not checked due to errors\n"
msgstr "%d Beglaubigungen aufgrund von Fehlern nicht geprüft\n"
#: g10/keyedit.c:194
msgid "1 user id without valid self-signature detected\n"
msgstr "Eine User-ID ohne gültige Eigenbeglaubigung entdeckt\n"
#: g10/keyedit.c:196
#, c-format
msgid "%d user ids without valid self-signatures detected\n"
msgstr "%d User-IDs ohne gültige Eigenbeglaubigung entdeckt\n"
#: g10/keyedit.c:258
#, c-format
msgid "Already signed by key %08lX\n"
msgstr "Ist bereits durch Schlüssel %08lX beglaubigt.\n"
#: g10/keyedit.c:266
#, c-format
msgid "Nothing to sign with key %08lX\n"
msgstr "Nichts zu beglaubigen für Schlüssel %08lX\n"
#: g10/keyedit.c:275
msgid ""
"Are you really sure that you want to sign this key\n"
"with your key: \""
msgstr ""
"Sind Sie wirklich sicher, daß Sie diesen Schlüssel mit Ihrem\n"
"Schlüssel beglaubigen wollen: \""
#: g10/keyedit.c:282
msgid "Really sign? "
msgstr "Wurklich unterschreiben? "
#: g10/keyedit.c:303 g10/sign.c:65
#, c-format
msgid "signing failed: %s\n"
msgstr "BEglaubigung fehlgeschlagen: %s\n"
#: g10/keyedit.c:356
msgid "This key is not protected.\n"
msgstr "Dieser Schlüssel ist nicht geschützt.\n"
#: g10/keyedit.c:359
msgid "Key is protected.\n"
msgstr "Schlüssel ist geschützt.\n"
#: g10/keyedit.c:376
#, c-format
msgid "Can't edit this key: %s\n"
msgstr "Dieser Schlüssel kann nicht editiert werden: %s\n"
#: g10/keyedit.c:381
msgid ""
"Enter the new passphrase for this secret key.\n"
"\n"
msgstr ""
"Geben Sie das neue Mantra für diesen geheimen Schlüssel ein.\n"
"\n"
#: g10/keyedit.c:393
msgid ""
"You don't want a passphrase - this is probably a *bad* idea!\n"
"\n"
msgstr ""
"Sie wollen kein Mantra - dies ist bestimmt *keine* gute Idee!\n"
"\n"
#: g10/keyedit.c:396
msgid "Do you really want to do this? "
msgstr "Möchten Sie dies wirklich tun? "
#: g10/keyedit.c:455
msgid "moving a key signature to the correct place\n"
msgstr "schiebe eine Beglaubigung an die richtige Stelle\n"
#: g10/keyedit.c:490
msgid "quit"
msgstr "quit"
#: g10/keyedit.c:490
msgid "quit this menu"
msgstr "Menü verlassen"
#: g10/keyedit.c:491
msgid "q"
msgstr "q"
#: g10/keyedit.c:492
msgid "save"
msgstr "save"
#: g10/keyedit.c:492
msgid "save and quit"
msgstr "speichern und Menü verlassen"
#: g10/keyedit.c:493
msgid "help"
msgstr "help"
#: g10/keyedit.c:493
msgid "show this help"
msgstr "Diese Hilfe zeigen"
#: g10/keyedit.c:495
msgid "fpr"
msgstr "fpr"
#: g10/keyedit.c:495
msgid "show fingerprint"
msgstr "\"Fingerabdruck\" anzeigen"
#: g10/keyedit.c:496
msgid "list"
msgstr "Liste der Schlüssel"
#: g10/keyedit.c:496
msgid "list key and user ids"
msgstr "Schlüssel und User-ID auflisten"
#: g10/keyedit.c:497
msgid "l"
msgstr "l"
#: g10/keyedit.c:498
msgid "uid"
msgstr "uid"
#: g10/keyedit.c:498
msgid "select user id N"
msgstr "User-ID N auswählen"
#: g10/keyedit.c:499
msgid "key"
msgstr "key"
#: g10/keyedit.c:499
msgid "select secondary key N"
msgstr "Zweitschlüssel N auswählen"
#: g10/keyedit.c:500
msgid "check"
msgstr "check"
#: g10/keyedit.c:500
msgid "list signatures"
msgstr "Liste der Signaturen"
#: g10/keyedit.c:501
msgid "c"
msgstr "c"
#: g10/keyedit.c:502
msgid "sign"
msgstr "sign"
#: g10/keyedit.c:502
msgid "sign the key"
msgstr "Den Schlüssel signieren"
#: g10/keyedit.c:503
msgid "s"
msgstr "s"
#: g10/keyedit.c:504
msgid "debug"
msgstr "debug"
#: g10/keyedit.c:505
msgid "adduid"
msgstr "adduid"
#: g10/keyedit.c:505
msgid "add a user id"
msgstr "Eine User-ID hinzufügen"
#: g10/keyedit.c:506
msgid "deluid"
msgstr "deluid"
#: g10/keyedit.c:506
msgid "delete user id"
msgstr "User-ID entfernen"
#: g10/keyedit.c:507
msgid "addkey"
msgstr "addkey"
#: g10/keyedit.c:507
msgid "add a secondary key"
msgstr "Einen Zweitschlüssel hinzufügen"
#: g10/keyedit.c:508
msgid "delkey"
msgstr "delkey"
#: g10/keyedit.c:508
msgid "delete a secondary key"
msgstr "Einen Zweitschlüssel entfernen"
#: g10/keyedit.c:509
msgid "expire"
msgstr "expire"
#: g10/keyedit.c:509
msgid "change the expire date"
msgstr "Ändern des Verfallsdatums"
#: g10/keyedit.c:510
msgid "toggle"
msgstr "toggle"
#: g10/keyedit.c:510
msgid "toggle between secret and public key listing"
msgstr "Umschalten zwischen Anzeige geheimer und öffentlicher Schlüssel"
#: g10/keyedit.c:512
msgid "t"
msgstr "t"
#: g10/keyedit.c:513
msgid "pref"
msgstr "pref"
#: g10/keyedit.c:513
msgid "list preferences"
msgstr "Liste der Voreinstellungen"
#: g10/keyedit.c:514
msgid "passwd"
msgstr "passwd"
#: g10/keyedit.c:514
msgid "change the passphrase"
msgstr "Das Mantra ändern"
#: g10/keyedit.c:515
msgid "trust"
msgstr "trust"
#: g10/keyedit.c:515
msgid "change the ownertrust"
msgstr "Den \"Owner trust\" ändern"
#: g10/keyedit.c:534
msgid "can't do that in batchmode\n"
msgstr "Dies kann im Batchmodus nicht durchgeführt werden.\n"
#. check that they match
#. FIXME: check that they both match
#: g10/keyedit.c:561
msgid "Secret key is available.\n"
msgstr "Geheimer Schlüssel ist vorhanden.\n"
#: g10/keyedit.c:590
msgid "Command> "
msgstr "Befehl> "
#: g10/keyedit.c:617
msgid "Need the secret key to do this.\n"
msgstr "Hierzu wird der geheime Schlüssel benötigt.\n"
#: g10/keyedit.c:639
msgid "Save changes? "
msgstr "Änderungen speichern? "
#: g10/keyedit.c:642
msgid "Quit without saving? "
msgstr "Beenden ohne zu speichern? "
#: g10/keyedit.c:652
#, c-format
msgid "update failed: %s\n"
msgstr "Änderung fehlgeschlagen: %s\n"
#: g10/keyedit.c:659
#, c-format
msgid "update secret failed: %s\n"
msgstr "Änderung des Geheimnisses fehlgeschlagen: %s\n"
#: g10/keyedit.c:666
msgid "Key not changed so no update needed.\n"
msgstr "Schlüssel ist nicht geändert worden, also ist keine Änderung nötig.\n"
#: g10/keyedit.c:669 g10/keyedit.c:727
#, c-format
msgid "update of trust db failed: %s\n"
msgstr "Änderung der \"Trust-DB\" fehlgeschlagen: %s\n"
#: g10/keyedit.c:701
msgid "Really sign all user ids? "
msgstr "Wirklich alle User-IDs beglaubigen? "
#: g10/keyedit.c:702
msgid "Hint: Select the user ids to sign\n"
msgstr "Tip: Wählen Sie die User-ID, die beglaubigt werden soll\n"
#: g10/keyedit.c:738
msgid "You must select at least one user id.\n"
msgstr "Zumindestens eine User-ID muß ausgewählt werden.\n"
#: g10/keyedit.c:740
msgid "You can't delete the last user id!\n"
msgstr "Die letzte User-ID kann nicht gelöscht werden!\n"
#: g10/keyedit.c:743
msgid "Really remove all selected user ids? "
msgstr "Möchten Sie alle ausgewählten User-IDs wirklich entfernen? "
#: g10/keyedit.c:744
msgid "Really remove this user id? "
msgstr "Diese User-ID wirklich entfernen? "
#: g10/keyedit.c:767
msgid "You must select at least one key.\n"
msgstr "Zumindestens ein Schlüssel muß ausgewählt werden.\n"
#: g10/keyedit.c:771
msgid "Do you really want to delete the selected keys? "
msgstr "Möchten Sie die ausgewählten Schlüssel wirklich entfernen? "
#: g10/keyedit.c:772
msgid "Do you really want to delete this key? "
msgstr "Möchten Sie diesen Schlüssel wirklich entfernen? "
#: g10/keyedit.c:819
msgid "Invalid command (try \"help\")\n"
msgstr "Ungültiger Befehl (versuchen Sie's mal mit \"help\")\n"
#: g10/keyedit.c:1197
msgid "Please remove selections from the secret keys.\n"
msgstr "Bitte entfernen Sie die Auswahl von den geheimen Schlüsseln.\n"
#: g10/keyedit.c:1203
msgid "Please select at most one secondary key.\n"
msgstr "Bitte wählen Sie höchstens einen Zweitschlüssel aus.\n"
#: g10/keyedit.c:1207
msgid "Changing exiration time for a secondary key.\n"
msgstr "Ändern des Verfallsdatums des Zweitschlüssels.\n"
#: g10/keyedit.c:1209
msgid "Changing exiration time for the primary key.\n"
msgstr "Ändern des Verfallsdatums des Hauptschlüssels.\n"
#: g10/keyedit.c:1250
msgid "You can't change the expiration date of a v3 key\n"
msgstr "Sie können das Verfallsdatum eines v3-Schlüssels nicht ändern\n"
#: g10/keyedit.c:1266
msgid "No corresponding signature in secret ring\n"
msgstr "Keine entsprechende Signatur im geheimen Schlüsselbund\n"
#: g10/keyedit.c:1326
#, c-format
msgid "No user id with index %d\n"
msgstr "Keine User-ID mit Index %d\n"
#: g10/keyedit.c:1371
#, c-format
msgid "No secondary key with index %d\n"
msgstr "Kein Zweitschlüssel mit Index %d\n"
#: g10/mainproc.c:198
msgid "public key encrypted data: Good DEK\n"
msgstr "Mit öffentlichem Schüssel verschlüsselte Daten: Korrekte DEK\n"
#: g10/mainproc.c:201
#, c-format
msgid "public key decryption failed: %s\n"
msgstr "Entschlüsselung mit öffentlichem Schlüssel fehlgeschlagen: %s\n"
#: g10/mainproc.c:228
msgid "decryption okay\n"
msgstr "Enschlüsselung fehlgeschlagen: %s\n"
#: g10/mainproc.c:231
#, c-format
msgid "decryption failed: %s\n"
msgstr "Enschlüsselung fehlgeschlagen: %s\n"
#: g10/mainproc.c:248
msgid "NOTE: sender requested \"for-your-eyes-only\"\n"
msgstr ""
"Hinweis: Der Absender verlangte Vertraulichkeit(\"for-your-eyes-only\")\n"
#: g10/mainproc.c:250
#, c-format
msgid "original file name='%.*s'\n"
msgstr "Ursprünglicher Dateiname='%.*s'\n"
#: g10/mainproc.c:833
msgid "signature verification suppressed\n"
msgstr "Unterschriften-Überprüfung unterdrückt\n"
#: g10/mainproc.c:839
#, c-format
msgid "Signature made %.*s using %s key ID %08lX\n"
msgstr "Unterschrieben am %.*s mit %s Schlüssel %08lX\n"
#: g10/mainproc.c:847
msgid "BAD signature from \""
msgstr "FALSCHE Unterschrift von \""
#: g10/mainproc.c:848
msgid "Good signature from \""
msgstr "Korrekte Unterschrift von \""
#: g10/mainproc.c:861
#, c-format
msgid "Can't check signature: %s\n"
msgstr "Signatur kann nicht geprüft werden: %s\n"
#: g10/mainproc.c:934
msgid "old style (PGP 2.x) signature\n"
msgstr "Unterschrift nach alter (PGP 2.x) Art\n"
#: g10/mainproc.c:939
msgid "invalid root packet detected in proc_tree()\n"
msgstr "ungültiges root-Paket in proc_tree() entdeckt\n"
#: g10/misc.c:88
#, c-format
msgid "can't disable core dumps: %s\n"
msgstr "core-dump-Erzeugung kann nicht abgeschaltet werden: %s\n"
#: g10/misc.c:90
msgid "WARNING: Program may create a core file!\n"
msgstr "WARNUNG: Programm könnte einen core-dump schreiben!\n"
#: g10/parse-packet.c:109
#, c-format
msgid "can't handle public key algorithm %d\n"
msgstr "dieses Public-Key Verfahren %d kann nicht benutzt werden\n"
#: g10/passphrase.c:141
msgid ""
"\n"
"You need a passphrase to unlock the secret key for\n"
"user: \""
msgstr ""
"\n"
"Sie benötigen ein Mantra, um den geheimen Schlüssel zu entsperren.\n"
"Benutzer: \""
#: g10/passphrase.c:150
#, c-format
msgid "(%u-bit %s key, ID %08lX, created %s)\n"
msgstr "(%u-Bit %s Schlüssel, ID %08lX, erzeugt %s)\n"
#: g10/passphrase.c:174
msgid "Enter passphrase: "
msgstr "Geben Sie das Mantra ein: "
#: g10/passphrase.c:178
msgid "Repeat passphrase: "
msgstr "Geben Sie das Mantra nochmal ein: "
#: g10/plaintext.c:102
msgid "data not saved; use option \"--output\" to save it\n"
msgstr ""
"Daten wurden nicht gespeichert; verwenden Sie dafür die Option \"--output\"\n"
#: g10/plaintext.c:215
msgid "Please enter name of data file: "
msgstr "Bitte geben Sie den Namen der Datendatei ein: "
#: g10/plaintext.c:236
msgid "reading stdin ...\n"
msgstr "lese stdin ...\n"
#: g10/plaintext.c:299
#, c-format
msgid "can't open signed data '%s'\n"
msgstr "kann signierte Datei '%s' nicht öffnen.\n"
#: g10/pubkey-enc.c:78
#, c-format
msgid "anonymous receiver; trying secret key %08lX ...\n"
msgstr "Ungenannter Empfänger: Versuch mit geheimen Schlüssel %08lX ...\n"
#: g10/pubkey-enc.c:84
msgid "okay, we are the anonymous receiver.\n"
msgstr "Alles klar, wir sind der ungenannte Empfänger.\n"
#: g10/pubkey-enc.c:136
msgid "old encoding of the DEK is not supported\n"
msgstr "alte Kodierung des DEK wird nicht unterstützt\n"
#: g10/pubkey-enc.c:183
#, c-format
msgid "NOTE: cipher algorithm %d not found in preferences\n"
msgstr "Hinweis: Verfahren %d ist kein bevorzugtes Verschlüsselungsverfahren\n"
#: g10/seckey-cert.c:56
#, c-format
msgid "protection algorithm %d is not supported\n"
msgstr "Schutzverfahren %d wird nicht unterstützt\n"
#: g10/seckey-cert.c:169
msgid "Invalid passphrase; please try again ...\n"
msgstr "Ungültiges Mantra; versuchen Sie's doch noch einmal ...\n"
#: g10/seckey-cert.c:215
msgid "WARNING: Weak key detected - please change passphrase again.\n"
msgstr ""
"WARNUNG: Unsicherer Schlüssel entdeckt -\n"
" bitte das Mantra nochmal eingeben.\n"
#: g10/sig-check.c:155
msgid ""
"this is a PGP generated ElGamal key which is NOT secure for signatures!\n"
msgstr ""
"Dieser durch PGP erzeugte ElGamal-Schlüssel ist für Signaturen NICHT sicher "
"genug!\n"
#: g10/sig-check.c:165
msgid "public key created in future (time warp or clock problem)\n"
msgstr ""
"Öffentlicher Schlüssel wurde in der Zukunft erzeugt (Zeitreise oder Uhren "
"stimmen nicht überein)\n"
#: g10/sig-check.c:170
#, c-format
msgid "NOTE: signature key expired %s\n"
msgstr "Hinweis: Schlüssel der Signatur ist verfallen am %s.\n"
#: g10/sign.c:69
#, c-format
msgid "%s signature from: %s\n"
msgstr "%s Unterschrift von: %s\n"
#: g10/sign.c:200 g10/sign.c:558
#, c-format
msgid "can't create %s: %s\n"
msgstr "%s kann nicht erzeugt werden: %s\n"
#: g10/sign.c:296
msgid "signing:"
msgstr "unterschreibe:"
#: g10/sign.c:336
#, c-format
msgid "WARNING: '%s' is an empty file\n"
msgstr "WARNUNG: '%s' ist eine leere Datei.\n"
#: g10/tdbio.c:116 g10/tdbio.c:1413
#, c-format
msgid "trustdb rec %lu: lseek failed: %s\n"
msgstr "trustdb Satz %lu: lseek fehlgeschlagen: %s\n"
#: g10/tdbio.c:122 g10/tdbio.c:1420
#, c-format
msgid "trustdb rec %lu: write failed (n=%d): %s\n"
msgstr "trustdb Satz %lu: write fehlgeschlagen (n=%d): %s\n"
#: g10/tdbio.c:232
msgid "trustdb transaction to large\n"
msgstr "trustdb Transaktion zu groß\n"
#: g10/tdbio.c:402
#, c-format
msgid "%s: can't access: %s\n"
msgstr "%s: kann nicht zugegriffen werden: %s\n"
#: g10/ringedit.c:273 g10/tdbio.c:422
#, c-format
msgid "%s: can't create directory: %s\n"
msgstr "%s: Verzeichnis kann nicht erzeugt werden: %s\n"
#: g10/ringedit.c:279 g10/tdbio.c:425
#, c-format
msgid "%s: directory created\n"
msgstr "%s: Verzeichnis erzeugt\n"
#: g10/tdbio.c:429
#, c-format
msgid "%s: directory does not exist!\n"
msgstr "%s: Verzeichnis existiert nicht!\n"
#: g10/openfile.c:101 g10/openfile.c:165 g10/ringedit.c:1256 g10/tdbio.c:435
#, c-format
msgid "%s: can't create: %s\n"
msgstr "%s: kann nicht erzeugt werden: %s\n"
#: g10/tdbio.c:459
#, c-format
msgid "%s: failed to create version record: %s"
msgstr "%s: Fehler beim Erzeugen des Versionsatzes: %s"
#: g10/tdbio.c:463
#, c-format
msgid "%s: invalid trust-db created\n"
msgstr "%s: ungültige trust-db erzeugt\n"
#: g10/tdbio.c:465
#, c-format
msgid "%s: trust-db created\n"
msgstr "%s: trust-db erzeugt\n"
#: g10/tdbio.c:506
#, c-format
msgid "%s: invalid trust-db\n"
msgstr "%s: ungülte 'Trust'-Datenbank\n"
#: g10/tdbio.c:540
#, c-format
msgid "%s: failed to create hashtable: %s\n"
msgstr "%s: hashtable kann nicht erzeugt werden: %s\n"
#: g10/tdbio.c:548
#, c-format
msgid "%s: error updating version record: %s\n"
msgstr "%s: Fehler beim Ändern des Versionsatzes: %s\n"
#: g10/tdbio.c:564 g10/tdbio.c:603 g10/tdbio.c:628 g10/tdbio.c:1346
#: g10/tdbio.c:1373
#, c-format
msgid "%s: error reading version record: %s\n"
msgstr "%s: Fehler beim Lesen des Versionsatzes: %s\n"
#: g10/tdbio.c:577
#, c-format
msgid "%s: error writing version record: %s\n"
msgstr "%s: Fehler beim Schreiben des Versionsatzes: %s\n"
#: g10/tdbio.c:1053
#, c-format
msgid "trustdb: lseek failed: %s\n"
msgstr "trustdb: lseek fehlgeschlagen: %s\n"
#: g10/tdbio.c:1061
#, c-format
msgid "trustdb: read failed (n=%d): %s\n"
msgstr "trustdb: read failed (n=%d): %s\n"
#: g10/tdbio.c:1082
#, c-format
msgid "%s: not a trustdb file\n"
msgstr "%s: keine trustdb Datei\n"
#: g10/tdbio.c:1098
#, c-format
msgid "%s: version record with recnum %lu\n"
msgstr "%s: version record with recnum %lu\n"
#: g10/tdbio.c:1103
#, c-format
msgid "%s: invalid file version %d\n"
msgstr "%s: invalid file version %d\n"
#: g10/tdbio.c:1379
#, c-format
msgid "%s: error reading free record: %s\n"
msgstr "%s: Fehler beim Lesen eines freien Satzes: %s\n"
#: g10/tdbio.c:1387
#, c-format
msgid "%s: error writing dir record: %s\n"
msgstr "%s: Fehler beim Schreiben eines Verzeichnis-Satzes: %s\n"
#: g10/tdbio.c:1397
#, c-format
msgid "%s: failed to zero a record: %s\n"
msgstr "%s: konnte einen Satz nicht Nullen: %s\n"
#: g10/tdbio.c:1427
#, c-format
msgid "%s: failed to append a record: %s\n"
msgstr "%s: konnte Satz nicht anhängen: %s\n"
#: g10/trustdb.c:134
msgid "The trust DB is corrupted; please run \"gpgm --fix-trust-db\".\n"
msgstr ""
"Die \"Trust\"-Datenbank ist beschädigt; verwenden Sie \"gpgm "
"--fix-trustdb\".\n"
#: g10/trustdb.c:147
#, c-format
msgid "trust record %lu, req type %d: read failed: %s\n"
msgstr "trust record %lu, req type %d: read failed: %s\n"
#: g10/trustdb.c:162
#, c-format
msgid "trust record %lu, type %d: write failed: %s\n"
msgstr "trust record %lu, type %d: write failed: %s\n"
#: g10/trustdb.c:176
#, c-format
msgid "trust record %lu: delete failed: %s\n"
msgstr "Vertrauenssatz %lu: löschen fehlgeschlagen: %s\n"
#: g10/trustdb.c:190
#, c-format
msgid "trust db: sync failed: %s\n"
msgstr "\"Trust-DB\": sync fehlgeschlagen: %s\n"
#: g10/trustdb.c:319
#, c-format
msgid "error reading dir record for LID %lu: %s\n"
msgstr "Fehler beim Lesen des Dir-Satzes für LID %lu: %s\n"
#: g10/trustdb.c:326
#, c-format
msgid "lid %lu: expected dir record, got type %d\n"
msgstr "lid %lu: Dir-Satz erwartet, aber es kam Typ %d\n"
#: g10/trustdb.c:331
#, c-format
msgid "no primary key for LID %lu\n"
msgstr "Kein Hauptschlüssel für LID %lu\n"
#: g10/trustdb.c:336
#, c-format
msgid "error reading primary key for LID %lu: %s\n"
msgstr "Fehler beim Lesen den Hauptschlüssels der LID %lu: %s\n"
#: g10/trustdb.c:412
#, c-format
msgid "chained sigrec %lu has a wrong owner\n"
msgstr "Verketteter Signatursatz %lu hat einen falschen Besitzer\n"
#: g10/trustdb.c:455
#, c-format
msgid "'%s' is not a valid long keyID\n"
msgstr "'%s' ist keine gültige lange Schlüssel-ID\n"
#: g10/trustdb.c:490
#, c-format
msgid "key %08lX: no public key for trusted key - skipped\n"
msgstr "Schlüssel %08lX: kein öffentlicher Schüssel für vertrauenswürdigen Schlüssel - übersprungen\n"
#: g10/trustdb.c:499 g10/trustdb.c:557
#, c-format
msgid "key %08lX: can't put it into the trustdb\n"
msgstr "Schlüssel %08lX kann nicht in die \"trustdb\" eingefügt werden\n"
#: g10/trustdb.c:504 g10/trustdb.c:563
#, c-format
msgid "key %08lX: query record failed\n"
msgstr "Schlüssel %08lX: Satzabfrage fehlgeschlagen\n"
#: g10/trustdb.c:509 g10/trustdb.c:572
#, c-format
msgid "key %08lX: already in trusted key table\n"
msgstr "Schlüssel %08lX: Ist bereits in geheimer Schlüsseltabelle\n"
#: g10/trustdb.c:512 g10/trustdb.c:575
#, c-format
msgid "key %08lX: accepted as trusted key.\n"
msgstr "Schlüssel %08lX: Akzeptiert als vertrauenswürdiger Schlüssel.\n"
#: g10/trustdb.c:528
#, c-format
msgid "NOTE: secret key %08lX is NOT protected.\n"
msgstr "HINWEIS: Geheimer Schlüssel %08lX ist NICHT geschützt.\n"
#: g10/trustdb.c:540
#, c-format
msgid "key %08lX: secret key without public key - skipped\n"
msgstr "Schlüssel %08lX: geheimer Schlüssel, aber ohne öffentlichen Schlüssel - übersprungen\n"
#: g10/trustdb.c:547
#, c-format
msgid "key %08lX: secret and public key don't match\n"
msgstr ""
"Schlüssel %08lX: geheimer und öffentlicher Schlüssel passen nicht zusammen.\n"
#: g10/trustdb.c:583
#, c-format
msgid "enumerate secret keys failed: %s\n"
msgstr "enum_secret_keys fehlgeschlagen: %s\n"
#: g10/trustdb.c:766
#, c-format
msgid "lid %lu: read dir record failed: %s\n"
msgstr "lid %lu: Lesen des Verz.Satzes fehlgeschlagen: %s\n"
#: g10/trustdb.c:775
#, c-format
msgid "lid %lu: read key record failed: %s\n"
msgstr "lid %lu: Lesen des Schl..Satzes fehlgeschlagen: %s\n"
#: g10/trustdb.c:785
#, c-format
msgid "lid %lu: read uid record failed: %s\n"
msgstr "lid %lu: Lesen des UserID-Satzes fehlgeschlagen: %s\n"
#: g10/trustdb.c:794
#, c-format
msgid "lid %lu: read pref record failed: %s\n"
msgstr "lid %lu: Lesen des Pref.Satzes fehlgeschlagen: %s\n"
#: g10/trustdb.c:804
#, c-format
msgid "lid %lu: read sig record failed: %s\n"
msgstr "lid %lu: Lesen des Sig.Satzes fehlgeschlagen: %s\n"
#: g10/trustdb.c:999
msgid "Ooops, no keys\n"
msgstr "Huch, keine Schlüssel\n"
#: g10/trustdb.c:1003
msgid "Ooops, no user ids\n"
msgstr "Huch, keine User-IDs\n"
#: g10/trustdb.c:1074 g10/trustdb.c:1092
#, c-format
msgid "user '%s' read problem: %s\n"
msgstr "User '%s' Leseproblem: %s\n"
#: g10/trustdb.c:1077 g10/trustdb.c:1095
#, c-format
msgid "user '%s' list problem: %s\n"
msgstr "User '%s' Listenproblem: %s\n"
#: g10/trustdb.c:1085 g10/trustdb.c:1300
#, c-format
msgid "user '%s' not found: %s\n"
msgstr "Benutzer '%s' nicht gefunden: %s\n"
#: g10/trustdb.c:1087 g10/trustdb.c:1302
#, c-format
msgid "problem finding '%s' in trustdb: %s\n"
msgstr "Problem, '%s' in der Trust-DB zu finden: %s\n"
#: g10/trustdb.c:1090
#, c-format
msgid "user '%s' not in trustdb\n"
msgstr "User '%s' ist nicht in der trustdb\n"
#: g10/trustdb.c:1125
#, c-format
msgid ""
"# List of assigned trustvalues, created %s\n"
"# (Use \"gpgm --import-ownertrust\" to restore them)\n"
msgstr ""
"# Liste der zugewisenen \"trustvalues\", erzeugt am %s\n"
"# (Verwenden Sie \"gpgm --import-ownertrust\" um sie wieder einzuspielen)\n"
#: g10/trustdb.c:1131
msgid "directory record w/o primary key\n"
msgstr "Verzeichnis-Satz ohne Hauptschlüssel\n"
#: g10/trustdb.c:1138
#, c-format
msgid "error reading key record: %s\n"
msgstr "Fehler beim Lesen des Schl.Satzes: %s\n"
#: g10/trustdb.c:1178
-msgid "line to long\n"
+msgid "line too long\n"
msgstr "Zeile zu lang\n"
#: g10/trustdb.c:1186
msgid "error: missing colon\n"
msgstr "Fehler: Fehlender Doppelpunkt\n"
#: g10/trustdb.c:1191
msgid "error: invalid fingerprint\n"
msgstr "Fehler: ungültiger Fingerabdruck\n"
#: g10/trustdb.c:1195
msgid "error: no ownertrust value\n"
msgstr "Fehler: Keine \"Owner trust\" Werte\n"
#: g10/trustdb.c:1209
#, c-format
msgid "LID %lu: changing trust from %u to %u\n"
msgstr "LID %lu: Ändern des 'Trusts' von %u auf %u\n"
#: g10/trustdb.c:1212
#, c-format
msgid "LID %lu: setting trust to %u\n"
msgstr "LID %lu: Setze 'Trust' auf %u\n"
#: g10/trustdb.c:1220
msgid "key not in trustdb, searching ring.\n"
msgstr "Schlüssel ist nicht in der trustdb, Schl.bund wird durchsucht.\n"
#: g10/trustdb.c:1223
#, c-format
msgid "key not in ring: %s\n"
msgstr "Schlüssel ist nicht im Schlüsselbund: %s\n"
#: g10/trustdb.c:1227
msgid "Oops: key is now in trustdb???\n"
msgstr "Huch: Schlüssel ist ja gar nicht in der Trust-DB?\n"
#. update the ownertrust
#: g10/trustdb.c:1232
#, c-format
msgid "insert trust record failed: %s\n"
msgstr "'trust record' einfügen fehlgeschlagen: %s\n"
#. error
#: g10/trustdb.c:1238
#, c-format
msgid "error finding dir record: %s\n"
msgstr "Fehler beim Auffinden des Verz.Satzes: %s\n"
#: g10/trustdb.c:1305
#, c-format
msgid "user '%s' not in trustdb - inserting\n"
msgstr "User '%s' ist nich in der 'Trust'-Datenbank - wird eingefügt\n"
#: g10/trustdb.c:1308
#, c-format
msgid "failed to put '%s' into trustdb: %s\n"
msgstr "konnte '%s' nicht in die 'Trust'-Datenbank hineintun: %s\n"
#: g10/trustdb.c:1355
#, c-format
msgid "%s: keyblock read problem: %s\n"
msgstr "%s: Schlüsselblock Leseproblem: %s\n"
#: g10/trustdb.c:1369
#, c-format
msgid "%s: update failed: %s\n"
msgstr "%s: Änderung fehlgeschlagen: %s\n"
#: g10/trustdb.c:1372
#, c-format
msgid "%s: updated\n"
msgstr "%s: geändert\n"
#: g10/trustdb.c:1374
#, c-format
msgid "%s: okay\n"
msgstr "%s: In Ordnung\n"
#: g10/trustdb.c:1389
#, c-format
msgid "lid %lu: dir record w/o key - skipped\n"
msgstr "lid %lu: Dir-Satz ohne Schlüssel - übergangen\n"
#: g10/trustdb.c:1402
#, c-format
msgid "lid %lu: keyblock not found: %s\n"
msgstr "lid %lu: Schlüsselblock nicht gefunden: %s\n"
#: g10/trustdb.c:1411 g10/trustdb.c:1480
#, c-format
msgid "lid %lu: update failed: %s\n"
msgstr "lid %lu: Änderung fehlgeschlagen: %s\n"
#: g10/trustdb.c:1417 g10/trustdb.c:1486
#, c-format
msgid "lid %lu: updated\n"
msgstr "lid %lu: geändert\n"
#: g10/trustdb.c:1421 g10/trustdb.c:1490
#, c-format
msgid "lid %lu: okay\n"
msgstr "lid %lu: In Ordnung\n"
#: g10/trustdb.c:1428 g10/trustdb.c:1496
#, c-format
msgid "%lu keys processed\n"
msgstr "%lu Schlüssel bearbeitet\n"
#: g10/trustdb.c:1430
#, c-format
msgid "\t%lu keys skipped\n"
msgstr "\t%lu Schlüssel übersprungen\n"
#: g10/trustdb.c:1432 g10/trustdb.c:1498
#, c-format
msgid "\t%lu keys with errors\n"
msgstr "\t%lu Schlüssel mit Fehlern\n"
#: g10/trustdb.c:1434 g10/trustdb.c:1500
#, c-format
msgid "\t%lu keys updated\n"
msgstr "\t%lu Schlüssel geändert\n"
#: g10/trustdb.c:1464
#, c-format
msgid "lid ?: insert failed: %s\n"
msgstr "lid ?: Einfügen fehlgeschlagen: %s\n"
#: g10/trustdb.c:1469
#, c-format
msgid "lid %lu: insert failed: %s\n"
msgstr "lid %lu: Einfügen fehlgeschlagen: %s\n"
#: g10/trustdb.c:1475
#, c-format
msgid "lid %lu: inserted\n"
msgstr "lid %lu: eingefügt\n"
#: g10/trustdb.c:1502
#, c-format
msgid "\t%lu keys inserted\n"
msgstr "\t%lu Schlüssel eingefügt\n"
#: g10/trustdb.c:1505
#, c-format
msgid "enumerate keyblocks failed: %s\n"
msgstr "enumerate Schlüsselblock fehlgeschlagen: %s\n"
#: g10/trustdb.c:1550
#, c-format
msgid "check_trust: search dir record failed: %s\n"
msgstr "check_trust: Suche nach Dir-Satz fehlgeschlagen: %s\n"
#: g10/trustdb.c:1557
#, c-format
msgid "key %08lX: insert trust record failed: %s\n"
msgstr "Schlüssel %08lX: 'trust record' einfügen fehlgeschlagen: %s\n"
#: g10/trustdb.c:1561
#, c-format
msgid "key %08lX.%lu: inserted into trustdb\n"
msgstr "Schlüssel %08lX.%lu: in \"trustdb\" eingefügt\n"
#: g10/trustdb.c:1569
#, c-format
msgid "key %08lX.%lu: created in future (time warp or clock problem)\n"
msgstr ""
"Schlüssel %08lX.%lu: wurde in der Zukunft erzeugt (Zeitreise oder Uhren "
"stimmen nicht überein)\n"
#: g10/trustdb.c:1576
#, c-format
msgid "key %08lX.%lu: expired at %s\n"
msgstr "Schlüssel %08lX.%lu: verfallen am %s\n"
#: g10/trustdb.c:1584
#, c-format
msgid "key %08lX.%lu: trust check failed: %s\n"
msgstr "Schlüssel %08lX.%lu: Vertrauensprüfung fehlgeschlagen: %s\n"
#: g10/trustdb.c:1753 g10/trustdb.c:1782 g10/trustdb.c:2521
msgid "WARNING: can't yet handle long pref records\n"
msgstr "WARNUNG: Lange 'Pref'-Records können noch nicht benutzt werden\n"
#: g10/trustdb.c:1804
#, c-format
msgid "get_dir_record: search_record failed: %s\n"
msgstr "get_dir_record: search_record fehlgeschlagen: %s\n"
#: g10/trustdb.c:1867
#, c-format
msgid "NOTE: sig rec %lu[%d] in hintlist of %lu but marked as checked\n"
msgstr "Hinweis: sig rec %lu[%d] in hintlist of %lu but marked as checked\n"
#: g10/trustdb.c:1871
#, c-format
msgid "NOTE: sig rec %lu[%d] in hintlist of %lu but not marked\n"
msgstr "Hinweis: sig rec %lu[%d] in hintlist of %lu but not marked\n"
#. we need the dir record
#: g10/trustdb.c:1878
#, c-format
msgid "sig rec %lu[%d] in hintlist of %lu does not point to a dir record\n"
msgstr "sig rec %lu[%d] in hintlist of %lu does not point to a dir record\n"
#: g10/trustdb.c:1884
#, c-format
msgid "lid %lu: no primary key\n"
msgstr "lid %lu: kein Hauptschlüssel\n"
#: g10/trustdb.c:1917
#, c-format
msgid "lid %lu: user id not found in keyblock\n"
msgstr "lid %lu: User-ID im Schlüsselblock nicht gefunden\n"
#: g10/trustdb.c:1921
#, c-format
msgid "lid %lu: user id without signature\n"
msgstr "lid %lu: User-ID ohne Signatur\n"
#: g10/trustdb.c:1928
#, c-format
msgid "lid %lu: self-signature in hintlist\n"
msgstr "lid %lu: Eigenbeglaubigung in 'hintlist'\n"
#: g10/trustdb.c:1939 g10/trustdb.c:2658 g10/trustdb.c:2742
msgid "Valid certificate revocation"
msgstr "Gültiger Zerifikat-Widerruf"
#: g10/trustdb.c:1940 g10/trustdb.c:2659 g10/trustdb.c:2743
msgid "Good certificate"
msgstr "Korrektes Zertifikat"
#: g10/trustdb.c:1949
msgid "very strange: no public key\n"
msgstr "sehr seltsam: kein öffentlicher Schlüssel\n"
#: g10/trustdb.c:1997
#, c-format
msgid "hintlist %lu[%d] of %lu does not point to a dir record\n"
msgstr "hintlist %lu[%d] of %lu zeigt nicht auf einen 'dir record'\n"
#: g10/trustdb.c:2003
#, c-format
msgid "lid %lu does not have a key\n"
msgstr "lid %lu hat keinen Schlüssel\n"
#: g10/trustdb.c:2013
#, c-format
msgid "lid %lu: can't get keyblock: %s\n"
msgstr "lid %lu: Schlüsselblock nicht verfügbar: %s\n"
#: g10/trustdb.c:2070 g10/trustdb.c:2984
#, c-format
msgid "tdbio_search_dir failed: %s\n"
msgstr "tdbio_search_dir fehlgeschlagen: %s\n"
#: g10/trustdb.c:2223
#, c-format
msgid "key %08lX.%lu: Good subkey binding\n"
msgstr "Schlüssel %08lX.%lu: Korrekte Unterschlüssel-Anbindung\n"
#: g10/trustdb.c:2229 g10/trustdb.c:2271
#, c-format
msgid "key %08lX.%lu: Invalid subkey binding: %s\n"
msgstr "Schlüssel %08lX.%lu: Ungültige Unterschlüssel-Anbindung\n"
#: g10/trustdb.c:2244
#, c-format
msgid "key %08lX.%lu: Valid key revocation\n"
msgstr "Schlüssel %08lX.%lu: Gültiger Schlüsselwiderruf\n"
#: g10/trustdb.c:2250
#, c-format
msgid "key %08lX.%lu: Invalid key revocation: %s\n"
msgstr "Schlüssel %08lX.%lu: Ungültiger Schlüsselwiderruf: %s\n"
#: g10/trustdb.c:2265
#, c-format
msgid "key %08lX.%lu: Valid subkey revocation\n"
msgstr "Schlüssel %08lX.%lu: Gültiger Unterschlüsselwiderruf\n"
#: g10/trustdb.c:2365
msgid "Good self-signature"
msgstr "Korrekte Eigenbeglaubigung"
#: g10/trustdb.c:2376
msgid "Invalid self-signature"
msgstr "Ungültige Eigenbeglaubigung"
#: g10/trustdb.c:2386
msgid "Valid user ID revocation skipped due to a newer self signature\n"
msgstr "Gültiger User-ID-Widerruf ignoriert, da eine neuere Eigenbeglaubigung vorliegt\n"
#: g10/trustdb.c:2393
msgid "Valid user ID revocation\n"
msgstr "Gültiger User-ID-Widerruf\n"
#: g10/trustdb.c:2400
msgid "Invalid user ID revocation"
msgstr "Ungültiger User-ID-Widerruf"
#: g10/trustdb.c:2484
msgid "Too many preferences"
msgstr "Zu viele Einstellungen"
#: g10/trustdb.c:2498
msgid "Too many preference items"
msgstr "Zu viele Angaben zur Bevorzugung"
#: g10/trustdb.c:2637
msgid "Duplicated certificate - deleted"
msgstr "Doppelte Zertifikate - entfernt"
#: g10/trustdb.c:2670
msgid "Hmmm, public key lost?"
msgstr "Hmmm, öffentlicher Schüssel verloren?"
#: g10/trustdb.c:2680 g10/trustdb.c:2763
msgid "Invalid certificate revocation"
msgstr "Ungültiger Zertifikatswiderruf"
#: g10/trustdb.c:2681 g10/trustdb.c:2764
msgid "Invalid certificate"
msgstr "Ungültiges Zertifikat"
#: g10/trustdb.c:2696
#, c-format
msgid "uid %08lX.%lu/%02X%02X: has shadow dir %lu but is not yet marked.\n"
msgstr "uid %08lX.%lu/%02X%02X: hat \"shadow-dir\" %lu, aber ist noch nicht markiert.\n"
#: g10/trustdb.c:2710
#, c-format
msgid "sig record %lu[%d] points to wrong record.\n"
msgstr "Signatursatz %lu[%d] zeigt auf falschen Satz.\n"
#. that should never happen
#: g10/trustdb.c:2954
#, c-format
msgid "insert_trust_record: keyblock not found: %s\n"
msgstr "insert_trust_record: Schlüsselblock nicht gefunden: %s\n"
#: g10/trustdb.c:2972
msgid "did not use primary key for insert_trust_record()\n"
msgstr "Für insert_trust_record() wurde nicht der Hauptschlüssel benutzt\n"
#: g10/ringedit.c:293
#, c-format
msgid "%s: can't create keyring: %s\n"
msgstr "%s: Schlüsselbund kann nicht erzeugt werden: %s\n"
#: g10/ringedit.c:299 g10/ringedit.c:1264
#, c-format
msgid "%s: keyring created\n"
msgstr "%s: Schlüsselbund erstellt\n"
#: g10/ringedit.c:1449
msgid "WARNING: 2 files with confidential information exists.\n"
msgstr "Warnung: Zwei Dateien mit vertraulichem Inhalt vorhanden.\n"
#: g10/ringedit.c:1450
#, c-format
msgid "%s is the unchanged one\n"
msgstr "%s ist der Unveränderte\n"
#: g10/ringedit.c:1451
#, c-format
msgid "%s is the new one\n"
msgstr "%s ist der Neue\n"
#: g10/ringedit.c:1452
msgid "Please fix this possible security flaw\n"
msgstr "Bitte diesen potentiellen Sicherheitsmangel beseitigen\n"
#: g10/skclist.c:94
#, c-format
msgid "skipped '%s': %s\n"
msgstr "übersprungen '%s': %s\n"
#: g10/skclist.c:100
#, c-format
msgid ""
"skipped '%s': this is a PGP generated ElGamal key which is not secure for "
"signatures!\n"
msgstr ""
"'%s übersprungen: Dies ist ein durch PGP erzeugter ElGamal-Schlüssel. Das "
"ist für Signaturen NICHT sicher genug!\n"
#. do not overwrite
#: g10/openfile.c:58
#, c-format
msgid "File '%s' exists. "
msgstr "Datei '%s' existiert bereits. "
#: g10/openfile.c:60
msgid "Overwrite (y/N)? "
msgstr "Überschreiben (j/N)? "
#: g10/openfile.c:85
msgid "writing to stdout\n"
msgstr "Schreiben auf die Standardausgabe\n"
#: g10/openfile.c:134
#, c-format
msgid "assuming signed data in '%s'\n"
msgstr "die unterzeichneten Daten sind wohl in '%s'\n"
#: g10/openfile.c:181
#, c-format
msgid "%s: new options file created\n"
msgstr "%s: neue Optionendatei erstellt\n"
#: g10/encr-data.c:59
#, c-format
msgid "%s encrypted data\n"
msgstr "%s verschlüsselte Daten\n"
#: g10/encr-data.c:61
#, c-format
msgid "encrypted with unknown algorithm %d\n"
msgstr "Mit unbekanntem Verfahren verschlüsselt %d\n"
#: g10/encr-data.c:74
msgid ""
"WARNING: Message was encrypted with a weak key in the symmetric cipher.\n"
msgstr ""
"Warnung: Botschaft wurde mit einem unsicheren Schlüssel verschlüsselt.\n"
#: g10/seskey.c:52
msgid "weak key created - retrying\n"
msgstr "Unsicherer Schlüssel erzeugt - neuer Versuch\n"
#: g10/seskey.c:57
#, c-format
msgid "cannot avoid weak key for symmetric cipher; tried %d times!\n"
msgstr ""
"Trotz %d-fachen Versuch konnte die Erzeugung eines unsicheren Schlüssels für "
"sym.Verschlüsselung nicht vermieden werden!\n"
#. begin of list
#: g10/helptext.c:45
#"It's up to you to assign a value here; this value will never be exported\n"
#"to any 3rd party. We need it to implement the web-of-trust; it has nothing\n"
#"to do with the (implicitly created) web-of-certificates."
msgid "edit_ownertrust.value"
msgstr ""
"SIE müssen hier einen Wert eingeben. Dieser Wert wird niemals an eine Dritte\n"
"weitergegeben (exportiert) werden. Wir brauchen ihn zum Aufbau des\n"
"\"web-of-trust\", Er hat nichts mit dem (stillschweigend aufgebautem)\n"
"\"web-of-certificates\" zu tun."
#: g10/helptext.c:51
#"If you want to use this revoked key anyway, answer \"yes\"."
msgid "revoked_key.override"
msgstr ""
"Wenn Sie diesen widerrufenen Schlüssel trotzdem benutzen wollen,\n"
"so antworten Sie mit \"ja\" oder schweigen für immer."
#: g10/helptext.c:55
#"If you want to use this untrusted key anyway, answer \"yes\"."
msgid "untrusted_key.override"
msgstr ""
"Wenn Sie diesen nichtvertruenswürdigen Schlüssel trotzdem benutzen wollen,\n"
"so antworten Sie mit \"ja\" oder schweigen Sie für immer."
#: g10/helptext.c:59
#"Enter the user id of the addresse to whom you want to send the message."
msgid "pklist.user_id.enter"
msgstr "Geben Sie die User-ID dessen ein, an den Sie die Botschaft senden wollen."
#: g10/helptext.c:63
msgid "keygen.algo"
msgstr ""
"Wählen Sie die zu verwendende Methode aus.\n"
"DSA (alias DSS) bedeutet \"digital signature algorithm\" (Digitales\n"
" Unterschrift-Verfahren). Es kann nur zum Unterschreiben und Beglaubigen\n"
" benutzt werden. Dies ist das empfohlene Verfahren, da dessen Überprüfung\n"
" wesentlich schneller abläuft, als die von \"ElGamal\".\n"
"\n"
"ElGamal ist ein Verfahren für Unterschrift, Beglaubigung und "
"Verschlüsselung\n"
" OpenPGP unterscheidet zwischen zwei Arten von ElGamal: eines nur zum\n"
" Unterschreiben/Beglaubigen und eines zusätzlich zum Verschlüsseln.\n"
" Eigentlich sind diese Arten identisch; allerdings müssen einige Parameter\n"
" auf eine besondere Art gewählt werden, um einen sicheren Schlüssel für\n"
" Unterschriften zu erzeugen. Dieses Programm macht dies zwar so, aber "
"andere\n"
" Programme sind nach OpenPGP-Spezifikation nicht verpflichtet die zweite "
"Art\n"
" (die mit zusätzlichem Verschlüsseln) zu verstehen.\n"
"\n"
"Der Hauptschlüssel (\"primary Key\") muß auf jeden Fall zum Unterschreiben "
"fähig\n"
"sein. Deshalb kann ein Nur-Verschlüssel-ElGamal-Schlüssel dafür nicht\n"
"verwendet werden.\n"
"Auch sollte man \"ElGamal in einem v3-Paket\" nicht verwenden, denn solch "
"ein\n"
"Schlüssel ist nicht mit anderen Programmen nach der OpenPGP-Spezifikation\n"
"verträglich."
#: g10/helptext.c:80
#"Enter the size of the key"
msgid "keygen.size"
msgstr ""
"Wählen Sie die gewünschte Schlüssellänge.\n"
"\n"
"Ein langer Schlüssel bietet mehr Sicherheit, kostet aber auch mehr "
"Rechenzeit.\n"
"Ein kurzer Schlüssel ist nicht ganz so sicher, wird aber schneller "
"bearbeitet.\n"
"1024 Bit ist für den Heimgebrauch ein brauchbarer Wert. Wenn Sie aber z.B. "
"in\n"
"Atlanta, Georgia, USA für eine Limonandenfabrik arbeiten, und das Rezept\n"
"speichern wollen (\"SCHLEMMER!\"), so wären 2048 Bit kein schlechter Wert."
#: g10/helptext.c:84
#"Answer \"yes\" or \"no\""
msgid "keygen.size.huge.okay"
msgstr "Geben Sie \"Ja\" oder \"Nein\" ein"
#: g10/helptext.c:89
msgid "keygen.size.large.okay"
msgstr "Geben Sie \"Ja\" oder \"Nein\" ein"
#: g10/helptext.c:94
msgid "keygen.valid"
msgstr "Geben Sie den erforderlichen Wert ein"
#: g10/helptext.c:98
msgid "keygen.valid.okay"
msgstr "Geben Sie \"Ja\" oder \"Nein\" ein"
#: g10/helptext.c:103
# "Enter the name of the key holder"
msgid "keygen.name"
msgstr "Geben Sie den Namen des Schlüsselinhabers ein"
#: g10/helptext.c:108
#"please enter an optional but highly suggested email address"
msgid "keygen.email"
msgstr "Geben Sie eine E-Mail-Adresse ein. Dies ist zwar nicht notwendig,\n"
"aber empfehlenswert."
#: g10/helptext.c:112
# "Please enter an optional comment"
msgid "keygen.comment"
msgstr "Geben Sie (bei Bedarf) einen Kommentar ein"
#: g10/helptext.c:117
#"N to change the name.\n"
#"C to change the comment.\n"
#"E to change the email address.\n"
#"O to continue with key generation.\n"
#"Q to to quit the key generation."
msgid "keygen.userid.cmd"
msgstr ""
"N um den Namen zu ändern.\n"
"K um den Kommentar zu ändern.\n"
"E um die E-Mail-Adresse zu ändern.\n"
"F um mit der Schlüsselerzeugung fortzusetzen.\n"
"B um die Schlüsselerzeugung abbrechen."
#: g10/helptext.c:126
# "Answer \"yes\" (or just \"y\") if it is okay to generate the sub key."
msgid "keygen.sub.okay"
msgstr "Geben Sie \"Ja\" (oder nur \"j\") ein, um den Unterschlüssel zu erzeugen."
#: g10/helptext.c:130
# "Answer \"yes\" or \"no\""
msgid "sign_uid.okay"
msgstr "Geben Sie \"Ja\" oder \"Nein\" ein"
#: g10/helptext.c:135
# "Answer \"yes\" or \"no\""
msgid "change_passwd.empty.okay"
msgstr "Geben Sie \"Ja\" oder \"Nein\" ein"
#: g10/helptext.c:140
# "Please enter \"help\" to see the list of commands."
msgid "keyedit.cmd"
msgstr "Geben Sie \"help\" ein, um die Liste der Befehle einzusehen."
#: g10/helptext.c:144
# "Answer \"yes\" or \"no\""
msgid "keyedit.save.okay"
msgstr "Geben Sie \"Ja\" oder \"Nein\" ein"
#: g10/helptext.c:149
msgid "keyedit.cancel.okay"
msgstr "Geben Sie \"Ja\" oder \"Nein\" ein"
#: g10/helptext.c:153
# "Answer \"yes\" is you want to sign ALL the user IDs"
msgid "keyedit.sign_all.okay"
msgstr "Geben Sie \"Ja\" (oder nur \"j\") ein, um alle User-IDs zu beglaubigen"
#: g10/helptext.c:157
# "Answer \"yes\" if you really want to delete this user ID.\n"
# "All ceritifcates are then also lost!"
msgid "keyedit.remove.uid.okay"
msgstr "Geben Sie \"Ja\" (oder nur \"j\") ein, um diese User-ID zu LÖSCHEN.\n"
"Alle Zertifikate werden dann auch weg sein!"
#: g10/helptext.c:162
# "Answer \"yes\" if it is okay to delete the subkey"
msgid "keyedit.remove.subkey.okay"
msgstr "Geben Sie \"Ja\" (oder nur \"j\") ein, um diesen Unterschlüssel zu löschen"
# ################################
# ####### Help msgids ############
# ################################
#: g10/helptext.c:166
msgid "passphrase.enter"
msgstr ""
"Bitte geben Sie das Mantra ein. Dies ist ein geheimer Satz, der aus\n"
"beliebigen Zeichen bestehen kann. Was Sie eingegeben wird nicht angezeigt.\n\n"
"Zur ihrer eigenen Sicherbeit benutzen Sie bitte einen Satz, den sie sich\n"
"gut merken könne, der aber nicht leicht zu erraten ist; Zitate und andere\n"
"bekannte Texte sind eine SCHLECHTE Wahl, da diese mit Sicherheit online\n"
"verfügbar sind und durch entsprechende Programme zum Raten des Mantras\n"
"benutzt werden. Sätze mit persönlicher Bedeutung, die auch noch durch\n"
"falsche Groß-/Kleinschreibung und eingestreute Sonderzeichen verändert werden,\n"
"sind i.d.R. eine gute Wahl"
#: g10/helptext.c:173
msgid "passphrase.repeat"
msgstr ""
"Um sicher zu gehen, daß Sie sich bei der Eingabe des Mantras nicht\n"
"vertippt haben, geben Sie diese bitte nochmal ein. Nur wenn beide Eingaben\n"
"übereinstimmen, wird das Mantra akzeptiert."
#: g10/helptext.c:177
# "Give the name fo the file to which the signature applies"
msgid "detached_signature.filename"
msgstr "Geben Sie den Namen der Datei an, zu dem die abgetrennte Unterschrift gehört"
#: g10/helptext.c:181
# "Answer \"yes\" if it is okay to overwrite the file"
msgid "openfile.overwrite.okay"
msgstr "Geben Sie \"ja\" ein, wenn Sie die Datei überschreiben möchten"
#: g10/helptext.c:195
msgid "No help available"
msgstr "Keine Hilfe vorhanden."
#: g10/helptext.c:207
#, c-format
msgid "No help available for '%s'"
msgstr "Keine Hilfe für '%s' vorhanden."
#~ msgid "You will see a list of signators etc. here\n"
#~ msgstr "Sie sollten hier eigentlich eine Liste der Signierer sehen.\n"
#, fuzzy
#~ msgid "key %08lX.%lu, uid %02X%02X, sig %08lX: good signature (3)\n"
#~ msgstr "Schlüssel %08lX: Ungültige Eigenbeglaubigung\n"
#, fuzzy
#~ msgid ""
#~ "key %08lX.%lu, uid %02X%02X, sig %08lX: very strange: no public key\n"
#~ msgstr "Schlüssel %08lX: Keine User-ID für Signatur\n"
#, fuzzy
#~ msgid "key %08lX.%lu, uid %02X%02X, sig %08lX: invalid signature: %s\n"
#~ msgstr "Schlüssel %08lX: Ungültige Eigenbeglaubigung\n"
#, fuzzy
#~ msgid "key %08lX.%lu, uid %02X%02X: good self-signature\n"
#~ msgstr "Schlüssel %08lX: Ungültige Eigenbeglaubigung\n"
#, fuzzy
#~ msgid ""
#~ "key %08lX.%lu, uid %02X%02X, sig %08lX: duplicated signature - deleted\n"
#~ msgstr "Schlüssel %08lX: Ungültige Eigensignatur\n"
#, fuzzy
#~ msgid "key %08lX.%lu, uid %02X%02X, sig %08lX: good signature (1)\n"
#~ msgstr "Schlüssel %08lX: Ungültige Eigensignatur\n"
#, fuzzy
#~ msgid "key %08lX.%lu, uid %02X%02X, sig %08lX: weird: no public key\n"
#~ msgstr "Schlüssel %08lX: Keine User-ID für Signatur\n"
#, fuzzy
#~ msgid "key %08lX.%lu, uid %02X%02X, sig %08lX: good signature (2)\n"
#~ msgstr "Schlüssel %08lX: Ungültige Eigensignatur\n"
#, fuzzy
#~ msgid "key %08lX.%lu, uid %02X%02X, sig %08lX: no public key\n"
#~ msgstr "Schlüssel %08lX: Keine User-ID für Signatur\n"
#~ msgid "key %08lX: already in ultikey_table\n"
#~ msgstr "Schlüssel %08lX: bereits in der Tabelle der geheime Schlüssel\n"
#~ msgid "can't write keyring\n"
#~ msgstr "kann Schlüsselbund nicht schreiben\n"
#~ msgid "make a signature on a key in the keyring"
#~ msgstr "Schlüssel signieren"
#~ msgid "edit a key signature"
#~ msgstr "Bearbeiten der Signaturen eines Schlüssels"
#~ msgid "do not make any changes"
#~ msgstr "Keine wirklichen Änderungen durchführen"
#~ msgid ""
#~ "It's up to you to assign a value here; this value will never be exported\n"
#~ "to any 3rd party. We need it to implement the web-of-trust; it has nothing\n"
#~ "to do with the (implicitly created) web-of-certificates.\n"
#~ msgstr ""
#~ "Sie müssen selbt entscheiden, welchen Wert Sie hier eintragen; dieser Wert\n"
#~ "wird niemals an eine dritte Seite weitergegeben. Wir brauchen diesen Wert,\n"
#~ "um das \"Netz des Vertrauens\" aufzubauen. Dieses hat nichts mit dem "
#~ "(implizit\n"
#~ "erzeugten) \"Netz der Zertifikate\" zu tun.\n"
#~ msgid "public and secret subkey created.\n"
#~ msgstr "Öffentlicher und geheimer Schlüssel erzeugt.\n"
#~ msgid "No public key for %d signatures\n"
#~ msgstr "Kein öffentlicher Schlüssel für %d Signaturen\n"
#~ msgid "[User name not available] "
#~ msgstr "[Benuzername nicht verfügbar] "
#~ msgid "This is a BAD signature!\n"
#~ msgstr "Dies ist eine FALSCHE Signatur!\n"
#~ msgid "The signature could not be checked!\n"
#~ msgstr "Die Signatur konnte nicht geprüft werden!\n"
#~ msgid "Checking signatures of this public key certificate:\n"
#~ msgstr "Die Signaturen dieses Zertifikats werden überprüft:\n"
#~ msgid "Do you want to remove some of the invalid signatures? "
#~ msgstr "Möchten Sie einige der ungültigen Signaturen entfernen? "
#~ msgid "there is a secret key for this public key!\n"
#~ msgstr ""
#~ "Es gibt einen privaten Schlüssel zu diesem öffentlichen Schlüssel!\n"
#~ msgid "use option \"--delete-secret-key\" to delete it first.\n"
#~ msgstr ""
#~ "Benutzen Sie das Kommando \"--delete-secret-key\", um ihn vorab zu "
#~ "entfernen.\n"
#~ msgid "can't do that in batchmode without \"--yes\"\n"
#~ msgstr "Dies kann im Batchmodus ohne \"--yes\" nicht durchgeführt werden.\n"
#~ msgid "Delete this key from the keyring? "
#~ msgstr "Diesen Schlüssel aus dem Schlüsselbund löschen? "
#~ msgid "This is a secret key! - really delete? "
#~ msgstr "Dies ist ein privater Schlüssel! - Wirklich löschen? "
diff --git a/po/es_ES.po b/po/es_ES.po
index 6fb48aeae..d52e11c44 100644
--- a/po/es_ES.po
+++ b/po/es_ES.po
@@ -1,3116 +1,3116 @@
# Spanish messages for gnupg
# Urko Lusa <ulusa@lacueva.ddns.org>, 1998
# I've tried to mantain the terminology used by Armando Ramos
# <armando@clerval.org> is his PGP 2.3.6i translation.
# I also got inspiration from it.po by Marco d'Itri <md@linux.it>
msgid ""
msgstr ""
"POT-Creation-Date: 1998-12-10 20:11+0100\n"
"Content-Type: text/plain; charset=iso-8859-1\n"
"Date: 1998-11-13 10:49:25+0100\n"
"From: Urko Lusa <ulusa@lacueva.ddns.org>\n"
"Xgettext-Options: --default-domain=gnupg --directory=.. --add-comments "
"--keyword=_ --keyword=N_ --files-from=./POTFILES.in\n"
"Files: util/secmem.c util/argparse.c cipher/random.c cipher/rand-dummy.c "
"cipher/rand-unix.c cipher/rand-w32.c g10/g10.c g10/pkclist.c g10/keygen.c "
"g10/decrypt.c g10/encode.c g10/import.c g10/keyedit.c g10/keylist.c "
"g10/mainproc.c g10/passphrase.c g10/plaintext.c g10/pref.c g10/seckey-cert.c "
"g10/sig-check.c g10/sign.c g10/trustdb.c g10/verify.c\n"
#: util/secmem.c:77
msgid "Warning: using insecure memory!\n"
msgstr "Aviso: ¡se está usando memoria insegura!\n"
#: util/miscutil.c:143
msgid "yes"
msgstr "sí"
#: util/miscutil.c:144
msgid "yY"
msgstr "sS"
#: util/errors.c:54
msgid "General error"
msgstr "Error general"
#: util/errors.c:55
msgid "Unknown packet type"
msgstr "Formato desconocido"
#: util/errors.c:56
msgid "Unknown version"
msgstr "Versión desconocida"
#: util/errors.c:57
msgid "Unknown pubkey algorithm"
msgstr "Algoritmo de clave pública desconocido"
#: util/errors.c:58
msgid "Unknown digest algorithm"
msgstr "Algoritmo desconocido de resumen de mensaje"
#: util/errors.c:59
msgid "Bad public key"
msgstr "Clave pública incorrecta"
#: util/errors.c:60
msgid "Bad secret key"
msgstr "Clave secreta incorrecta"
#: util/errors.c:61
msgid "Bad signature"
msgstr "Firma incorrecta"
#: util/errors.c:62
msgid "Checksum error"
msgstr "Error en suma de comprobación"
#: util/errors.c:63
msgid "Bad passphrase"
msgstr "Contraseña incorrecta"
#: util/errors.c:64
msgid "Public key not found"
msgstr "Clave pública no encontrada"
#: util/errors.c:65
msgid "Unknown cipher algorithm"
msgstr "Algoritmo de cifrado desconocido"
#: util/errors.c:66
msgid "Can't open the keyring"
msgstr "No se puede abrir el anillo"
#: util/errors.c:67
msgid "Invalid packet"
msgstr "Valor no válido"
#: util/errors.c:68
msgid "Invalid armor"
msgstr "Armadura no válida"
#: util/errors.c:69
msgid "No such user id"
msgstr "No existe el identificativo de usuario"
#: util/errors.c:70
msgid "Secret key not available"
msgstr "Clave secreta no disponible"
#: util/errors.c:71
msgid "Wrong secret key used"
msgstr "Clave secreta incorrecta"
#: util/errors.c:72
msgid "Not supported"
msgstr "No soportado"
#: util/errors.c:73
msgid "Bad key"
msgstr "Clave incorrecta"
#: util/errors.c:74
msgid "File read error"
msgstr "Error de lectura"
#: util/errors.c:75
msgid "File write error"
msgstr "Error de escritura"
#: util/errors.c:76
msgid "Unknown compress algorithm"
msgstr "Algoritmo de compresión desconocido"
#: util/errors.c:77
msgid "File open error"
msgstr "Error al abrir fichero"
#: util/errors.c:78
msgid "File create error"
msgstr "Error al cerrar fichero"
#: util/errors.c:79
msgid "Invalid passphrase"
msgstr "Contraseña incorrecta"
#: util/errors.c:80
msgid "Unimplemented pubkey algorithm"
msgstr "Algoritmo de clave pública no implementado"
#: util/errors.c:81
msgid "Unimplemented cipher algorithm"
msgstr "Algoritmo de cifrado no implementado"
#: util/errors.c:82
msgid "Unknown signature class"
msgstr "Clase de firma desconocida"
#: util/errors.c:83
msgid "Trust database error"
msgstr "Error en la base de datos de confianza"
#: util/errors.c:84
msgid "Bad MPI"
msgstr "MPI incorrecto"
#: util/errors.c:85
msgid "Resource limit"
msgstr "Límite de recurso"
#: util/errors.c:86
msgid "Invalid keyring"
msgstr "Anillo no válido"
#: util/errors.c:87
msgid "Bad certificate"
msgstr "Certificado incorrecto"
#: util/errors.c:88
msgid "Malformed user id"
msgstr "Identificativo de usuario mal formado"
#: util/errors.c:89
msgid "File close error"
msgstr "Error al cerrar fichero"
#: util/errors.c:90
msgid "File rename error"
msgstr "Error al renombrar fichero"
#: util/errors.c:91
msgid "File delete error"
msgstr "Error al borrar fichero"
#: util/errors.c:92
msgid "Unexpected data"
msgstr "Datos inesperados"
#: util/errors.c:93
msgid "Timestamp conflict"
msgstr "Conflicto con sello de fecha"
#: util/errors.c:94
msgid "Unusable pubkey algorithm"
msgstr "Algoritmo de clave pública no utilizable"
#: util/errors.c:95
msgid "File exists"
msgstr "El fichero existe. "
#: util/errors.c:96
msgid "Weak key"
msgstr "Clave débil"
#: util/logger.c:178
#, fuzzy, c-format
msgid "... this is a bug (%s:%d:%s)\n"
msgstr "¡Oh! vaya... esto es un bug (%s:%d:%s)\n"
#: util/logger.c:184
#, c-format
msgid "you found a bug ... (%s:%d)\n"
msgstr "Ha encontrado Vd. un bug... (%s:%d)\n"
#: cipher/random.c:412
#, fuzzy
msgid "WARNING: using insecure random number generator!!\n"
msgstr "Aviso: ¡se está usando un generador de números aleatorios inseguro!\n"
#: cipher/random.c:413
msgid ""
"The random number generator is only a kludge to let\n"
"it run - it is in no way a strong RNG!\n"
"\n"
"DON'T USE ANY DATA GENERATED BY THIS PROGRAM!!\n"
"\n"
msgstr ""
"EL generador de números aleatorios es sólo un apaño\n"
"para poder compilar. ¡No es en absoluto seguro!\n"
"\n"
"¡NO USE NINGÚN DATO GENERADO POR ESTE PROGRAMA!\n"
"\n"
#: cipher/rndlinux.c:116
#, c-format
msgid ""
"\n"
"Not enough random bytes available. Please do some other work to give\n"
"the OS a chance to collect more entropy! (Need %d more bytes)\n"
msgstr ""
"\n"
"No hay suficientes bytes aleatorios disponibles. Por favor, haga algún\n"
"otro trabajo para que el sistema pueda recolectar más entropía\n"
"(se necesitan %d bytes más).\n"
#: g10/g10.c:159
msgid ""
"@Commands:\n"
" "
msgstr ""
"@Comandos:\n"
" "
#: g10/g10.c:162
msgid "|[file]|make a signature"
msgstr "|[file]|hace una firma"
#: g10/g10.c:163
msgid "|[file]|make a clear text signature"
msgstr "|[file]|hace una firma en texto claro"
#: g10/g10.c:164
msgid "make a detached signature"
msgstr "hace una firma separada"
#: g10/g10.c:165
msgid "encrypt data"
msgstr "cifra datos"
#: g10/g10.c:166
msgid "encryption only with symmetric cipher"
msgstr "cifra sólo con un cifrado simétrico"
#: g10/g10.c:167
msgid "store only"
msgstr "sólo almacenar"
#: g10/g10.c:168
msgid "decrypt data (default)"
msgstr "descifra datos (predefinido)"
#: g10/g10.c:169
msgid "verify a signature"
msgstr "verifica una firma"
#: g10/g10.c:171
msgid "list keys"
msgstr "lista las claves"
#: g10/g10.c:172
msgid "list keys and signatures"
msgstr "lista las claves y firmas"
#: g10/g10.c:173
msgid "check key signatures"
msgstr "comprueba las firmas de las claves"
#: g10/g10.c:174
msgid "list keys and fingerprints"
msgstr "lista las claves y huellas dactilares"
#: g10/g10.c:175
msgid "list secret keys"
msgstr "lista las claves secretas"
#: g10/g10.c:177
msgid "generate a new key pair"
msgstr "genera un nuevo par de claves"
#: g10/g10.c:179
msgid "remove key from the public keyring"
msgstr "elimina la clave del anillo público"
#: g10/g10.c:181
msgid "sign or edit a key"
msgstr "firma o modifica una clave"
#: g10/g10.c:182
msgid "generate a revocation certificate"
msgstr "genera un certificado de revocación"
#: g10/g10.c:184
msgid "export keys"
msgstr "exporta las claves"
#: g10/g10.c:187
msgid "import/merge keys"
msgstr "importa/fusiona las claves"
#: g10/g10.c:189
msgid "list only the sequence of packets"
msgstr "lista sólo la secuencia de paquetes"
#: g10/g10.c:192
msgid "export the ownertrust values"
msgstr "exporta los valores de confianza"
#: g10/g10.c:194
msgid "import ownertrust values"
msgstr "importa los valores de confianza"
#: g10/g10.c:196
msgid "|[NAMES]|update the trust database"
msgstr "|[NOMBRES]|actualiza la base de datos de confianza"
#: g10/g10.c:198
msgid "|[NAMES]|check the trust database"
msgstr "|[NOMBRES]|comprueba la base de datos de confianza"
#: g10/g10.c:199
msgid "fix a corrupted trust database"
msgstr "arregla una base de datos de confianza dañada"
#: g10/g10.c:200
msgid "De-Armor a file or stdin"
msgstr "quita la armadura de un fichero o stdin"
#: g10/g10.c:201
msgid "En-Armor a file or stdin"
msgstr "crea la armadura a un fichero o stdin"
#: g10/g10.c:202
msgid "|algo [files]|print message digests"
msgstr "|algo [files]|imprime resúmenes de mensaje"
#: g10/g10.c:203
msgid "print all message digests"
msgstr "imprime todos los resúmenes de mensaje"
#: g10/g10.c:210
msgid ""
"@\n"
"Options:\n"
" "
msgstr ""
"@\n"
"Opciones:\n"
" "
#: g10/g10.c:212
msgid "create ascii armored output"
msgstr "crea una salida ascii con armadura"
#: g10/g10.c:214
msgid "use this user-id to sign or decrypt"
msgstr "usa este usuario para firmar o descifrar"
#: g10/g10.c:215
msgid "use this user-id for encryption"
msgstr "usa este usuario para cifrar"
#: g10/g10.c:216
msgid "|N|set compress level N (0 disables)"
msgstr "|N|establece nivel de compresión N (0 no comprime)"
#: g10/g10.c:218
msgid "use canonical text mode"
msgstr "usa modo de texto canónico"
#: g10/g10.c:220
msgid "use as output file"
msgstr "usa como fichero de salida"
#: g10/g10.c:221
msgid "verbose"
msgstr "prolijo"
#: g10/g10.c:222
msgid "be somewhat more quiet"
msgstr ""
#: g10/g10.c:223
msgid "force v3 signatures"
msgstr "fuerza firmas v3"
#. { oDryRun, "dry-run", 0, N_("do not make any changes") },
#: g10/g10.c:225
msgid "batch mode: never ask"
msgstr "proceso por lotes: nunca preguntar"
#: g10/g10.c:226
msgid "assume yes on most questions"
msgstr "asume \"sí\" en casi todas las preguntas"
#: g10/g10.c:227
msgid "assume no on most questions"
msgstr "asume \"no\" en casi todas las preguntas"
#: g10/g10.c:228
msgid "add this keyring to the list of keyrings"
msgstr "añade este anillo a la lista de anillos"
#: g10/g10.c:229
msgid "add this secret keyring to the list"
msgstr "añade este anillo secreto a la lista"
#: g10/g10.c:230
msgid "|NAME|use NAME as default secret key"
msgstr "|NOMBRE|usa NOMBRE como clave secreta por defecto"
#: g10/g10.c:231
#, fuzzy
msgid "|NAME|set terminal charset to NAME"
msgstr "|NOMBRE|usa el algoritmo de cifrado NOMBRE"
#: g10/g10.c:232
msgid "read options from file"
msgstr "lee opciones del fichero"
#: g10/g10.c:234
msgid "set debugging flags"
msgstr "establece los parámetros de depuración"
#: g10/g10.c:235
msgid "enable full debugging"
msgstr "habilita depuración completa"
#: g10/g10.c:236
msgid "|FD|write status info to this FD"
msgstr "|DF|escribe información de estado en descriptor DF"
#: g10/g10.c:237
msgid "do not write comment packets"
msgstr "no escribe paquetes de comentario"
#: g10/g10.c:238
msgid "(default is 1)"
msgstr "(por defecto es 1)"
#: g10/g10.c:239
msgid "(default is 3)"
msgstr "(por defecto es 3)"
#: g10/g10.c:241
msgid "|KEYID|ulimately trust this key"
msgstr ""
#: g10/g10.c:242
msgid "|FILE|load extension module FILE"
msgstr "|FICHERO|carga módulo de extensiones FICHERO"
#: g10/g10.c:243
msgid "emulate the mode described in RFC1991"
msgstr "emula el modo descrito en la RFC1991"
#: g10/g10.c:244
msgid "|N|use passphrase mode N"
msgstr "|N|usa modo de contraseña N"
#: g10/g10.c:246
msgid "|NAME|use message digest algorithm NAME for passphrases"
msgstr ""
"|NOMBRE|usa algoritmo de resumen de mensaje NOMBRE\n"
"para las contraseñas"
#: g10/g10.c:248
msgid "|NAME|use cipher algorithm NAME for passphrases"
msgstr ""
"|NOMBRE|usa el algoritmo de cifrado NOMBRE para las\n"
"contraseñas"
#: g10/g10.c:250
msgid "|NAME|use cipher algorithm NAME"
msgstr "|NOMBRE|usa el algoritmo de cifrado NOMBRE"
#: g10/g10.c:251
msgid "|NAME|use message digest algorithm NAME"
msgstr "|NOMBRE|usa algoritmo de resumen de mensaje NOMBRE"
#: g10/g10.c:252
msgid "|N|use compress algorithm N"
msgstr "|N|usa el algoritmo de compresión N"
#: g10/g10.c:253
msgid "throw keyid field of encrypted packets"
msgstr "elimina el campo keyid de los paquetes cifrados"
#: g10/g10.c:261
msgid ""
"@\n"
"Examples:\n"
"\n"
" -se -r Bob [file] sign and encrypt for user Bob\n"
" --clearsign [file] make a clear text signature\n"
" --detach-sign [file] make a detached signature\n"
" --list-keys [names] show keys\n"
" --fingerprint [names] show fingerprints\n"
msgstr ""
"@\n"
"Ejemplos:\n"
"\n"
" -se -r Bob [fichero] firma y cifra para el usuario Bob\n"
" --clearsign [fichero] hace una firma manteniendo el texto sin cifrar\n"
" --detach-sign [fichero] hace una firma separada\n"
" --list-keys [nombres] muestra las claves\n"
" --fingerprint [nombres] muestra las huellas dactilares\n"
#: g10/g10.c:339
msgid "Please report bugs to <gnupg-bugs@gnu.org>.\n"
msgstr "Por favor, informe de posibles \"bugs\" a <gnupg-bugs@gnu.org>.\n"
#: g10/g10.c:344
msgid "Usage: gpgm [options] [files] (-h for help)"
msgstr "Uso: gpgm [opciones] [ficheros] (-h para ayuda)"
#: g10/g10.c:346
msgid "Usage: gpg [options] [files] (-h for help)"
msgstr "Uso: gpg [opciones] [ficheros] (-h para ayuda)"
#: g10/g10.c:351
msgid ""
"Syntax: gpgm [options] [files]\n"
"GnuPG maintenance utility\n"
msgstr ""
"Sintaxis: gpgm [opciones] [ficheros]\n"
"Utilidad de mantenimiento de GnuPG\n"
#: g10/g10.c:354
msgid ""
"Syntax: gpg [options] [files]\n"
"sign, check, encrypt or decrypt\n"
"default operation depends on the input data\n"
msgstr ""
"Sintaxis: gpg [opciones] [ficheros]\n"
"firma, comprueba, cifra o descifra\n"
"la operación por defecto depende del tipo de datos de entrada\n"
#: g10/g10.c:360
msgid ""
"\n"
"Supported algorithms:\n"
msgstr ""
"\n"
"Algoritmos soportados:\n"
#: g10/g10.c:435
msgid "usage: gpgm [options] "
msgstr "uso: gpgm [opciones] "
#: g10/g10.c:437
msgid "usage: gpg [options] "
msgstr "uso: gpg [opciones] "
#: g10/g10.c:478
msgid "conflicting commands\n"
msgstr "comandos incompatibles\n"
#: g10/g10.c:616
#, fuzzy, c-format
msgid "NOTE: no default option file '%s'\n"
msgstr "nota: no existe fichero de opciones predefinido '%s'\n"
#: g10/g10.c:620
#, c-format
msgid "option file '%s': %s\n"
msgstr "fichero de opciones '%s': %s\n"
#: g10/g10.c:627
#, c-format
msgid "reading options from '%s'\n"
msgstr "leyendo opciones desde '%s'\n"
#: g10/g10.c:776
#, fuzzy, c-format
msgid "%s is not a valid character set\n"
msgstr "Caracter no válido en el comentario\n"
#: g10/g10.c:810 g10/g10.c:822
msgid "selected cipher algorithm is invalid\n"
msgstr "el algoritmo de cifra seleccionado no es válido\n"
#: g10/g10.c:816 g10/g10.c:828
msgid "selected digest algorithm is invalid\n"
msgstr "el algoritmo de resumen seleccionado no es válido\n"
#: g10/g10.c:831
#, c-format
msgid "compress algorithm must be in range %d..%d\n"
msgstr "el algoritmo de compresión debe estar en el rango %d-%d\n"
#: g10/g10.c:833
msgid "completes-needed must be greater than 0\n"
msgstr "completes-needed debe ser mayor que 0\n"
#: g10/g10.c:835
msgid "marginals-needed must be greater than 1\n"
msgstr "marginals-needed debe ser mayor que 1\n"
#: g10/g10.c:837
msgid "max-cert-depth must be in range 1 to 255\n"
msgstr ""
#: g10/g10.c:840
#, fuzzy
msgid "NOTE: simple S2K mode (0) is strongly discouraged\n"
msgstr "nota: el modo S2K simple (0) no es nada recomendable\n"
#: g10/g10.c:844
msgid "invalid S2K mode; must be 0, 1 or 3\n"
msgstr "modo S2K incorrecto; debe ser 0, 1 o 3\n"
#: g10/g10.c:927
#, c-format
msgid "failed to initialize the TrustDB: %s\n"
msgstr "inicialización de la base de datos de confianza '%s' fallida\n"
#: g10/g10.c:933
msgid "--store [filename]"
msgstr "--store [nombre_fichero]"
#: g10/g10.c:941
msgid "--symmetric [filename]"
msgstr "--symmetric [nombre_fichero]"
#: g10/g10.c:949
msgid "--encrypt [filename]"
msgstr "--encrypt [nombre_fichero]"
#: g10/g10.c:962
msgid "--sign [filename]"
msgstr "--sign [nombre_fichero]"
#: g10/g10.c:975
msgid "--sign --encrypt [filename]"
msgstr "--sign --encrypt [nombre_fichero]"
#: g10/g10.c:989
msgid "--clearsign [filename]"
msgstr "--clearsign [nombre_fichero]"
#: g10/g10.c:1001
msgid "--decrypt [filename]"
msgstr "--decrypt [nombre_fichero]"
#: g10/g10.c:1010
#, fuzzy
msgid "--edit-key username [commands]"
msgstr "--edit-key nombre_usuario"
#: g10/g10.c:1026
msgid "--delete-secret-key username"
msgstr "--delete-secret-key nombre_usuario"
#: g10/g10.c:1029
msgid "--delete-key username"
msgstr "--delete-key nombre_usuario"
#: g10/encode.c:216 g10/g10.c:1052 g10/sign.c:301
#, c-format
msgid "can't open %s: %s\n"
msgstr "no puede abrirse '%s': %s\n"
#: g10/g10.c:1063
msgid "-k[v][v][v][c] [userid] [keyring]"
msgstr "-k[v][v][v][c] [id_usuario] [anillo]"
#: g10/g10.c:1120
#, c-format
msgid "dearmoring failed: %s\n"
msgstr "eliminación de armadura fallida: %s\n"
#: g10/g10.c:1128
#, c-format
msgid "enarmoring failed: %s\n"
msgstr "creación de armadura fallida: %s\n"
#: g10/g10.c:1194
#, c-format
msgid "invalid hash algorithm '%s'\n"
msgstr "algoritmo de distribución no válido '%s'\n"
#: g10/g10.c:1273
msgid "[filename]"
msgstr "[nombre_fichero]"
#: g10/g10.c:1277
msgid "Go ahead and type your message ...\n"
msgstr ""
#: g10/decrypt.c:59 g10/g10.c:1280 g10/verify.c:66
#, c-format
msgid "can't open '%s'\n"
msgstr "no puede abrirse '%s'\n"
#: g10/armor.c:344 g10/armor.c:391
msgid "armor header: "
msgstr "cabecera de armadura: "
#: g10/armor.c:355
msgid "invalid clearsig header\n"
msgstr "cabecera de firma clara no válida\n"
#: g10/armor.c:382
msgid "invalid armor header: "
msgstr "cabecera de armadura no válida: "
#: g10/armor.c:460
#, c-format
msgid "armor: %s\n"
msgstr "armadura: %s\n"
#: g10/armor.c:533
msgid "invalid dash escaped line: "
msgstr "Línea con guiones no válida: "
#: g10/armor.c:602
msgid "invalid clear text header: "
msgstr "cabecera de texto claro no válida: "
#: g10/armor.c:845
#, c-format
msgid "invalid radix64 character %02x skipped\n"
msgstr "caracteres no válidos radix64 %02x ignorados\n"
#: g10/armor.c:878
msgid "premature eof (no CRC)\n"
msgstr "Fin de fichero prematuro\n"
#: g10/armor.c:897
msgid "premature eof (in CRC)\n"
msgstr "Fin de suma de comprobación prematuro\n"
#: g10/armor.c:901
msgid "malformed CRC\n"
msgstr "Suma de comprobación mal creada\n"
#: g10/armor.c:905
#, c-format
msgid "CRC error; %06lx - %06lx\n"
msgstr "Error en suma de comprobación: %06lx - %06lx\n"
#: g10/armor.c:924
msgid "premature eof (in Trailer)\n"
msgstr ""
#: g10/armor.c:928
msgid "error in trailer line\n"
msgstr ""
#: g10/armor.c:1182
msgid "no valid RFC1991 or OpenPGP data found.\n"
msgstr "RFC1991 no válida o datos OpenPGP no encontrados\n"
#: g10/pkclist.c:121
#, fuzzy, c-format
msgid ""
"No trust value assigned to %lu:\n"
"%4u%c/%08lX %s \""
msgstr ""
"No hay confianza definida para el propietario %lu:\n"
"%4u%c/%08lX %s \""
#: g10/pkclist.c:131
msgid ""
"Please decide how far you trust this user to correctly\n"
"verify other users' keys (by looking at passports,\n"
"checking fingerprints from different sources...)?\n"
"\n"
" 1 = Don't know\n"
" 2 = I do NOT trust\n"
" 3 = I trust marginally\n"
" 4 = I trust fully\n"
" s = please show me more information\n"
msgstr ""
"Por favor, decida su nivel de confianza para este que usuario\n"
"verifique las claves de otros usuarios (mirando pasaportes,\n"
"comprobando huellas dactilares en diferentes fuentes...)\n"
"\n"
" 1 = No lo sé\n"
" 2 = NO me fío\n"
" 3 = Me fío marginalmente\n"
" 4 = Me fío completamente\n"
" i = Mostrar más información\n"
#: g10/pkclist.c:140
msgid " m = back to the main menu\n"
msgstr " m = volver al menú principal\n"
#. a string with valid answers
#: g10/pkclist.c:145
msgid "sSmM"
msgstr "iImM"
#: g10/pkclist.c:149
msgid "Your decision? "
msgstr "Su decisión: "
#: g10/pkclist.c:169
msgid "Certificates leading to an ultimately trusted key:\n"
msgstr ""
#: g10/pkclist.c:197
msgid ""
"Could not find a valid trust path to the key. Let's see whether we\n"
"can assign some missing owner trust values.\n"
"\n"
msgstr ""
"No puede encontrarse una ruta de confianza váida para esta clave. Veamos\n"
"si es posible asignar algunos valores de confianza perdidos.\n"
"\n"
#: g10/pkclist.c:219
msgid ""
"No path leading to one of our keys found.\n"
"\n"
msgstr ""
#: g10/pkclist.c:221
msgid ""
"No certificates with undefined trust found.\n"
"\n"
msgstr ""
#: g10/pkclist.c:223
#, fuzzy
msgid ""
"No trust values changed.\n"
"\n"
msgstr ""
"No se cambió ningún valor de confianza.\n"
"\n"
#: g10/pkclist.c:238
#, fuzzy, c-format
msgid "key %08lX: key has been revoked!\n"
msgstr "clave %08lX: aceptada como clave secreta.\n"
#: g10/pkclist.c:244 g10/pkclist.c:335
msgid "Use this key anyway? "
msgstr "¿Usar esta clave de todas formas? "
#: g10/pkclist.c:266
#, fuzzy, c-format
msgid "%08lX: key has expired\n"
msgstr "Nota: ¡Esta clave está caducada!\n"
#: g10/pkclist.c:272
#, c-format
msgid "%08lX: no info to calculate a trust probability\n"
msgstr ""
#: g10/pkclist.c:288
#, fuzzy, c-format
msgid "%08lX: We do NOT trust this key\n"
msgstr "ATENCIÓN: ¡Esta firma NO es de confianza!\n"
#: g10/pkclist.c:294
#, c-format
msgid ""
"%08lX: It is not sure that this key really belongs to the owner\n"
"but it is accepted anyway\n"
msgstr ""
#: g10/pkclist.c:300
msgid "This key probably belongs to the owner\n"
msgstr ""
#: g10/pkclist.c:305
msgid "This key belongs to us\n"
msgstr ""
#: g10/pkclist.c:330
msgid ""
"It is NOT certain that the key belongs to its owner.\n"
"If you *really* know what you are doing, you may answer\n"
"the next question with yes\n"
"\n"
msgstr ""
"No es seguro que la clave pertenezca a su propietario.\n"
"Si *realmente* sabe lo que está haciendo, puede contestar\n"
"\"sí\" a la siguiente pregunta.\n"
"\n"
#: g10/pkclist.c:339
msgid "WARNING: Using untrusted key!\n"
msgstr "ATENCIÓN: ¡Usando una clave no fiable!\n"
#: g10/pkclist.c:375
msgid "WARNING: This key has been revoked by its owner!\n"
msgstr "ATENCIÓN: ¡Esta clave ha sido revocada por su propietario!\n"
#: g10/pkclist.c:376
msgid " This could mean that the signature is forgery.\n"
msgstr " Esto puede significar que la firma está falsificada.\n"
#: g10/pkclist.c:397
msgid "Note: This key has expired!\n"
msgstr "Nota: ¡Esta clave está caducada!\n"
#: g10/pkclist.c:404
msgid "WARNING: This key is not certified with a trusted signature!\n"
msgstr ""
"ATENCIÓN: ¡Esta clave no está certificada por una firma de confianza!\n"
#: g10/pkclist.c:406
msgid ""
" There is no indication that the signature belongs to the owner.\n"
msgstr " No hay indicios de que la firma pertenezca al propietario.\n"
#: g10/pkclist.c:421
msgid "WARNING: We do NOT trust this key!\n"
msgstr "ATENCIÓN: ¡Esta firma NO es de confianza!\n"
#: g10/pkclist.c:422
msgid " The signature is probably a FORGERY.\n"
msgstr " La firma es probablemente una FALSIFICACIÓN.\n"
#: g10/pkclist.c:429
msgid ""
"WARNING: This key is not certified with sufficiently trusted signatures!\n"
msgstr ""
"AVISO: ¡Esta clave no está certificada con suficientes firmas de confianza!\n"
#: g10/pkclist.c:432
msgid " It is not certain that the signature belongs to the owner.\n"
msgstr " No es seguro que la firma pertenezca al propietario.\n"
#: g10/pkclist.c:477
msgid ""
"You did not specify a user ID. (you may use \"-r\")\n"
"\n"
msgstr ""
"No se ha especificado un ID de usuario (puede usar \"-r\")\n"
"\n"
#: g10/pkclist.c:482
msgid "Enter the user ID: "
msgstr "Introduzca el ID de usuario: "
#: g10/pkclist.c:493
msgid "No such user ID.\n"
msgstr "ID de usuario inexistente.\n"
#: g10/pkclist.c:527 g10/pkclist.c:554
#, c-format
msgid "%s: skipped: %s\n"
msgstr "%s: ignorado: %s\n"
#: g10/pkclist.c:535
#, c-format
msgid "%s: error checking key: %s\n"
msgstr "%s: error comprobando la clave: %s\n"
#: g10/pkclist.c:561
msgid "no valid addressees\n"
msgstr "no hay direcciones válidas\n"
#: g10/keygen.c:124
msgid "writing self signature\n"
msgstr "escribiendo autofirma\n"
#: g10/keygen.c:162
msgid "writing key binding signature\n"
msgstr ""
#: g10/keygen.c:388
msgid "Please select what kind of key you want:\n"
msgstr "Por favor seleccione tipo de clave deseado:\n"
#: g10/keygen.c:390
#, c-format
msgid " (%d) DSA and ElGamal (default)\n"
msgstr " (%d) DSA y ElGamal (por defecto)\n"
#: g10/keygen.c:391
#, c-format
msgid " (%d) DSA (sign only)\n"
msgstr " (%d) DSA (sólo firma)\n"
#: g10/keygen.c:393
#, c-format
msgid " (%d) ElGamal (encrypt only)\n"
msgstr " (%d) ElGamal (sólo cifrado)\n"
#: g10/keygen.c:394
#, c-format
msgid " (%d) ElGamal (sign and encrypt)\n"
msgstr " (%d) ElGamal (firma y cifrado)\n"
#: g10/keygen.c:396
#, c-format
msgid " (%d) ElGamal in a v3 packet\n"
msgstr " (%d) ElGamal en un paquete v3\n"
#: g10/keygen.c:401
msgid "Your selection? "
msgstr "Su elección: "
#: g10/keygen.c:411
#, fuzzy
msgid "Do you really want to create a sign and encrypt key? "
msgstr "¿Borrar realmente las claves seleccionadas? "
#: g10/keygen.c:432
msgid "Invalid selection.\n"
msgstr "Elección no válida.\n"
#: g10/keygen.c:444
#, c-format
msgid ""
"About to generate a new %s keypair.\n"
" minimum keysize is 768 bits\n"
" default keysize is 1024 bits\n"
" highest suggested keysize is 2048 bits\n"
msgstr ""
"Listo para generar un nuevo par de claves %s.\n"
" el tamaño mínimo es 768 bits\n"
" el tamaño por defecto es 1024 bits\n"
" el tamaño máximo recomendado en 2048 bits\n"
#: g10/keygen.c:451
msgid "What keysize do you want? (1024) "
msgstr "¿De qué tamaño quiere la clave (1024)? "
#: g10/keygen.c:456
msgid "DSA only allows keysizes from 512 to 1024\n"
msgstr "DSA sólo permite tamaños desde 512 a 1024\n"
#: g10/keygen.c:458
msgid "keysize too small; 768 is smallest value allowed.\n"
msgstr "tamaño insuficiente; 768 es el valor mínimo permitido\n"
#: g10/keygen.c:461
msgid ""
"Keysizes larger than 2048 are not suggested because\n"
"computations take REALLY long!\n"
msgstr ""
"No se recomiendan claves de más de 2048 bits porque\n"
"el tiempo de computación es REALMENTE largo.\n"
#: g10/keygen.c:464
msgid "Are you sure that you want this keysize? "
msgstr "¿Seguro que quiere una clave de este tamaño? "
#: g10/keygen.c:465
msgid ""
"Okay, but keep in mind that your monitor and keyboard radiation is also very "
"vulnerable to attacks!\n"
msgstr ""
"De acuerdo, ¡pero tenga en cuenta que las radiaciones de su monitor y "
"teclado\n"
"también son vulnerables a un ataque!\n"
#: g10/keygen.c:473
msgid "Do you really need such a large keysize? "
msgstr "¿De verdad necesita una clave tan grande? "
#: g10/keygen.c:479
#, c-format
msgid "Requested keysize is %u bits\n"
msgstr "El tamaño requerido es de %u bits\n"
#: g10/keygen.c:482 g10/keygen.c:486
#, c-format
msgid "rounded up to %u bits\n"
msgstr "redondeados a %u bits\n"
#: g10/keygen.c:499
msgid ""
"Please specify how long the key should be valid.\n"
" 0 = key does not expire\n"
" <n> = key expires in n days\n"
" <n>w = key expires in n weeks\n"
" <n>m = key expires in n months\n"
" <n>y = key expires in n years\n"
msgstr ""
"Por favor, especifique el período de validez de la clave.\n"
" 0 = la clave nunca caduca\n"
" <n> = la clave caduca en n días\n"
" <n>w = la clave caduca en n semanas\n"
" <n>m = la clave caduca en n meses\n"
" <n>y = la clave caduca en n años\n"
#: g10/keygen.c:514
msgid "Key is valid for? (0) "
msgstr "¿Validez de la clave (0)? "
#: g10/keygen.c:525
msgid "invalid value\n"
msgstr "valor no válido\n"
#: g10/keygen.c:530
msgid "Key does not expire at all\n"
msgstr "La clave nunca caduca\n"
#. print the date when the key expires
#: g10/keygen.c:536
#, c-format
msgid "Key expires at %s\n"
msgstr "La clave caduca el %s\n"
#: g10/keygen.c:542
msgid "Is this correct (y/n)? "
msgstr "¿Es correcto (s/n)? "
#: g10/keygen.c:584
msgid ""
"\n"
"You need a User-ID to identify your key; the software constructs the user "
"id\n"
"from Real Name, Comment and Email Address in this form:\n"
" \"Heinrich Heine (Der Dichter) <heinrichh@duesseldorf.de>\"\n"
"\n"
msgstr ""
"\n"
"Necesita un identificativo de usuario para identificar su clave. El "
"programa\n"
"construye el identificativo a partir del Nombre Real, Comentario y "
"Dirección\n"
"de Correo Electrónico de esta forma:\n"
" \"Heinrich Heine (Der Dichter) <heinrichh@duesseldorf.de>\"\n"
"\n"
#: g10/keygen.c:595
msgid "Real name: "
msgstr "Nombre y apellidos: "
#: g10/keygen.c:599
msgid "Invalid character in name\n"
msgstr "Caracter no válido en el nombre\n"
#: g10/keygen.c:601
msgid "Name may not start with a digit\n"
msgstr "El nombre no puede empezar con un número\n"
#: g10/keygen.c:603
msgid "Name must be at least 5 characters long\n"
msgstr "El nombre debe tener al menos 5 caracteres\n"
#: g10/keygen.c:611
msgid "Email address: "
msgstr "Dirección de correo electrónico: "
#: g10/keygen.c:623
msgid "Not a valid email address\n"
msgstr "Dirección no válida\n"
#: g10/keygen.c:631
msgid "Comment: "
msgstr "Comentario: "
#: g10/keygen.c:637
msgid "Invalid character in comment\n"
msgstr "Caracter no válido en el comentario\n"
#: g10/keygen.c:657
#, c-format
msgid ""
"You selected this USER-ID:\n"
" \"%s\"\n"
"\n"
msgstr ""
"Ha seleccionado este identificativo de usuario:\n"
" \"%s\"\n"
"\n"
#: g10/keygen.c:660
msgid "NnCcEeOoQq"
msgstr "NnCcDdVvSs"
#: g10/keygen.c:670
msgid "Change (N)ame, (C)omment, (E)mail or (O)kay/(Q)uit? "
msgstr "¿Cambia (N)ombre, (C)omentario, (D)irección o (V)ale/(S)alir? "
#: g10/keygen.c:722
msgid ""
"You need a Passphrase to protect your secret key.\n"
"\n"
msgstr ""
"Necesita una contraseña para proteger su clave secreta.\n"
"\n"
#: g10/keyedit.c:389 g10/keygen.c:730
msgid "passphrase not correctly repeated; try again.\n"
msgstr "contraseña repetida incorrecta, inténtelo de nuevo.\n"
#: g10/keygen.c:736
msgid ""
"You don't want a passphrase - this is probably a *bad* idea!\n"
"I will do it anyway. You can change your passphrase at any time,\n"
"using this program with the option \"--edit-key\".\n"
"\n"
msgstr ""
"No ha especificado contraseña. Esto es probablemente una *mala* idea.\n"
"Si más tarde quiere añadir una, puede hacerlo usando este programa con\n"
"la opción \"--edit-key\".\n"
"\n"
#: g10/keygen.c:757
msgid ""
"We need to generate a lot of random bytes. It is a good idea to perform\n"
"some other action (work in another window, move the mouse, utilize the\n"
"network and the disks) during the prime generation; this gives the random\n"
"number generator a better chance to gain enough entropy.\n"
msgstr ""
"Es necesario generar muchos bytes aleatorios. Es una buena idea realizar\n"
"alguna otra tarea (trabajar en otra ventana/consola, mover el ratón, usar\n"
"la red y los discos) durante la generación de números primos. Esto da al\n"
"generador de números aleatorios mayor oportunidad de recoger suficiente\n"
"entropía.\n"
#: g10/keygen.c:827
msgid "Key generation can only be used in interactive mode\n"
msgstr "La creación de claves sólo es posible en modo interactivo\n"
#: g10/keygen.c:835
msgid "DSA keypair will have 1024 bits.\n"
msgstr "El par de claves DSA tendrá 1024 bits.\n"
#: g10/keygen.c:841
msgid "Key generation cancelled.\n"
msgstr "Creación de claves cancelada.\n"
#: g10/keygen.c:851
#, c-format
msgid "writing public certificate to '%s'\n"
msgstr "escribiendo certificado público en '%s'\n"
#: g10/keygen.c:852
#, c-format
msgid "writing secret certificate to '%s'\n"
msgstr "escribiendo certificado privado en '%s'\n"
#: g10/keygen.c:929
msgid "public and secret key created and signed.\n"
msgstr "Claves pública y secreta creadas y firmadas.\n"
#: g10/keygen.c:931
msgid ""
"Note that this key cannot be used for encryption. You may want to use\n"
"the command \"--add-key\" to generate a secondary key for this purpose.\n"
msgstr ""
"Tenga en cuenta que esta clave no puede ser usada para cifrado. Puede usar\n"
"el comando \"--add-key\" para crear una clave secundaria con este "
"propósito.\n"
#: g10/keygen.c:945 g10/keygen.c:1030
#, c-format
msgid "Key generation failed: %s\n"
msgstr "Creación de la clave fallida: %s\n"
#: g10/keygen.c:1008
msgid "Really create? "
msgstr "¿Crear de verdad? "
#: g10/encode.c:88 g10/openfile.c:81 g10/openfile.c:158 g10/tdbio.c:445
#: g10/tdbio.c:504
#, c-format
msgid "%s: can't open: %s\n"
msgstr "%s: no puede abrirse: %s\n"
#: g10/encode.c:107
#, c-format
msgid "error creating passphrase: %s\n"
msgstr "error creando contraseña: %s\n"
#: g10/encode.c:155 g10/encode.c:269
#, fuzzy, c-format
msgid "%s: WARNING: empty file\n"
msgstr "%s: atención: fichero vacío\n"
#: g10/encode.c:222
#, c-format
msgid "reading from '%s'\n"
msgstr "leyendo desde '%s'\n"
#: g10/encode.c:397
#, fuzzy, c-format
msgid "%s/%s encrypted for: %s\n"
msgstr "%s cifrado para: %s\n"
#: g10/export.c:114
#, fuzzy, c-format
msgid "%s: user not found: %s\n"
msgstr "%s: usuario no encontrado\n"
#: g10/export.c:123
#, c-format
msgid "certificate read problem: %s\n"
msgstr ""
#: g10/export.c:132
#, fuzzy, c-format
msgid "key %08lX: not a rfc2440 key - skipped\n"
msgstr "clave %08lX: clave secreta sin clave pública - ignorada\n"
#: g10/export.c:174
#, fuzzy
msgid "WARNING: nothing exported\n"
msgstr "ATENCIÓN: ¡Usando una clave no fiable!\n"
#: g10/getkey.c:164
msgid "too many entries in pk cache - disabled\n"
msgstr ""
#: g10/getkey.c:263
msgid "too many entries in unk cache - disabled\n"
msgstr ""
#: g10/getkey.c:989
#, c-format
msgid "using secondary key %08lX instead of primary key %08lX\n"
msgstr "usando clave secundaria %08lX en vez de clave primaria %08lX\n"
#: g10/import.c:129 g10/trustdb.c:1166
#, c-format
msgid "can't open file: %s\n"
msgstr "no puede abrirse el fichero: %s\n"
#: g10/import.c:145
#, c-format
msgid "skipping block of type %d\n"
msgstr "ignorando bloque de tipo %d\n"
#: g10/import.c:152 g10/trustdb.c:1425 g10/trustdb.c:1494
#, c-format
msgid "%lu keys so far processed\n"
msgstr ""
#: g10/import.c:157 g10/trustdb.c:1242
#, c-format
msgid "read error: %s\n"
msgstr "error de lectura: %s\n"
#: g10/import.c:159
#, c-format
msgid "Total number processed: %lu\n"
msgstr ""
#: g10/import.c:161
#, c-format
msgid " w/o user IDs: %lu\n"
msgstr ""
#: g10/import.c:163
#, c-format
msgid " imported: %lu"
msgstr ""
#: g10/import.c:169
#, c-format
msgid " unchanged: %lu\n"
msgstr ""
#: g10/import.c:171
#, c-format
msgid " new user IDs: %lu\n"
msgstr ""
#: g10/import.c:173
#, c-format
msgid " new subkeys: %lu\n"
msgstr ""
#: g10/import.c:175
#, fuzzy, c-format
msgid " new signatures: %lu\n"
msgstr "clave %08lX: %d nuevas firmas\n"
#: g10/import.c:177
#, c-format
msgid " new key revocations: %lu\n"
msgstr ""
#: g10/import.c:179
#, fuzzy, c-format
msgid " secret keys read: %lu\n"
msgstr "enum_secret_keys fallido: %s\n"
#: g10/import.c:181
#, fuzzy, c-format
msgid " secret keys imported: %lu\n"
msgstr "clave %08lX: clave secreta importata\n"
#: g10/import.c:183
#, fuzzy, c-format
msgid " secret keys unchanged: %lu\n"
msgstr "enum_secret_keys fallido: %s\n"
#: g10/import.c:325 g10/import.c:517
#, c-format
msgid "key %08lX: no user id\n"
msgstr "clave %08lX: no hay id de usuario\n"
#: g10/import.c:336
#, c-format
msgid "key %08lX: no valid user ids\n"
msgstr "clave %08lX: no hay ids de usuario válidos\n"
#: g10/import.c:338
msgid "this may be caused by a missing self-signature\n"
msgstr "esto puede ser debido a la ausencia de autofirma\n"
#: g10/import.c:349 g10/import.c:585
#, c-format
msgid "key %08lX: public key not found: %s\n"
msgstr "clave %08lX: clave pública no encontrada: %s\n"
#: g10/import.c:355
msgid "no default public keyring\n"
msgstr "no hay anillo público por defecto\n"
#: g10/import.c:359 g10/openfile.c:105 g10/sign.c:205 g10/sign.c:569
#, c-format
msgid "writing to '%s'\n"
msgstr "escribiendo en '%s'\n"
#: g10/import.c:363 g10/import.c:423 g10/import.c:639
#, c-format
msgid "can't lock public keyring: %s\n"
msgstr "no puede bloquearse el anillo público: %s\n"
#: g10/import.c:366
#, c-format
msgid "can't write to keyring: %s\n"
msgstr "no puede escribirse en el anillo: %s\n"
#: g10/import.c:370
#, c-format
msgid "key %08lX: public key imported\n"
msgstr "clave %08lX: clave pública importada\n"
#: g10/import.c:383
#, c-format
msgid "key %08lX: doesn't match our copy\n"
msgstr "clave %08lX: no se corresponde con nuestra copia\n"
#: g10/import.c:396 g10/import.c:594
#, c-format
msgid "key %08lX: can't locate original keyblock: %s\n"
msgstr "clave %08lX: no puede localizarse el bloque de claves original: %s\n"
#: g10/import.c:403 g10/import.c:601
#, c-format
msgid "key %08lX: can't read original keyblock: %s\n"
msgstr "clave %08lX: no puede leerse el bloque de claves original: %s\n"
#: g10/import.c:420 g10/import.c:532 g10/import.c:636
msgid "writing keyblock\n"
msgstr "escribiendo bloque de claves\n"
#: g10/import.c:426 g10/import.c:642
#, c-format
msgid "can't write keyblock: %s\n"
msgstr "no puede escribirse el bloque de claves: %s\n"
#: g10/import.c:431
#, c-format
msgid "key %08lX: 1 new user-id\n"
msgstr "clave %08lX: 1 nuevo id de usuario\n"
#: g10/import.c:434
#, c-format
msgid "key %08lX: %d new user-ids\n"
msgstr "clave %08lX: %d nuevos ids de usuario\n"
#: g10/import.c:437
#, c-format
msgid "key %08lX: 1 new signature\n"
msgstr "clave %08lX: 1 nueva firma\n"
#: g10/import.c:440
#, c-format
msgid "key %08lX: %d new signatures\n"
msgstr "clave %08lX: %d nuevas firmas\n"
#: g10/import.c:443
#, c-format
msgid "key %08lX: 1 new subkey\n"
msgstr "clave %08lX: 1 nueva subclave\n"
#: g10/import.c:446
#, c-format
msgid "key %08lX: %d new subkeys\n"
msgstr "clave %08lX: %d nuevas subclaves\n"
#: g10/import.c:456
#, c-format
msgid "key %08lX: not changed\n"
msgstr "clave %08lX: sin cambios\n"
#: g10/import.c:535
#, c-format
msgid "can't lock secret keyring: %s\n"
msgstr "no puede bloquearse el anillo secreto: %s\n"
#: g10/import.c:538
#, c-format
msgid "can't write keyring: %s\n"
msgstr "no puede escribirse el anillo: %s\n"
#. we are ready
#: g10/import.c:541
#, c-format
msgid "key %08lX: secret key imported\n"
msgstr "clave %08lX: clave secreta importata\n"
#. we can't merge secret keys
#: g10/import.c:545
#, c-format
msgid "key %08lX: already in secret keyring\n"
msgstr "clave %08lX: ya estaba en el anillo secreto\n"
#: g10/import.c:550
#, c-format
msgid "key %08lX: secret key not found: %s\n"
msgstr "clave %08lX: clave secreta no encontrada: %s\n"
#: g10/import.c:579
#, c-format
msgid "key %08lX: no public key - can't apply revocation certificate\n"
msgstr ""
"clave %08lX: falta la clave pública - imposibile applicar el\n"
"certificado de revocación\n"
#: g10/import.c:612
#, c-format
msgid "key %08lX: invalid revocation certificate: %s - rejected\n"
msgstr "clave %08lX: certificado de revocación no válido: %s - rechazado\n"
#: g10/import.c:646
#, c-format
msgid "key %08lX: revocation certificate imported\n"
msgstr "clave %08lX: certificado de revocación importado\n"
#: g10/import.c:677
#, c-format
msgid "key %08lX: no user-id for signature\n"
msgstr "clave %08lX: no hay id de usuario para la firma\n"
#: g10/import.c:684
#, c-format
msgid "key %08lX: unsupported public key algorithm\n"
msgstr "clave %08lX: algoritmo da clave pública no soportado\n"
#: g10/import.c:685
#, c-format
msgid "key %08lX: invalid self-signature\n"
msgstr "clave %08lX: autofirma no válida\n"
#: g10/import.c:714
#, c-format
msgid "key %08lX: skipped userid '"
msgstr "clave %08lX: ignorado id de usuario '"
#: g10/import.c:737
#, c-format
msgid "key %08lX: revocation certificate at wrong place - skipped\n"
msgstr ""
"clave %08lX: certificado de revocación en sitio equivocado - ignorado\n"
#: g10/import.c:745
#, c-format
msgid "key %08lX: invalid revocation certificate: %s - skipped\n"
msgstr "clave %08lX: certificado de revocación no valido: %s - ignorado\n"
#: g10/import.c:804
#, c-format
msgid "key %08lX: revocation certificate added\n"
msgstr "clave %08lX: certificado de revocación añadido\n"
#: g10/import.c:918 g10/import.c:973
#, c-format
msgid "key %08lX: our copy has no self-signature\n"
msgstr "clave %08lX: nuestra copia no tiene autofirma\n"
#: g10/keyedit.c:81
#, c-format
msgid "%s: user not found\n"
msgstr "%s: usuario no encontrado\n"
#: g10/keyedit.c:164
msgid "[self-signature]"
msgstr "[autofirma]"
#: g10/keyedit.c:182
msgid "1 bad signature\n"
msgstr "1 firma incorrecta\n"
#: g10/keyedit.c:184
#, c-format
msgid "%d bad signatures\n"
msgstr "%d firmas incorrectas\n"
#: g10/keyedit.c:186
msgid "1 signature not checked due to a missing key\n"
msgstr "1 firma no comprobada por falta de clave\n"
#: g10/keyedit.c:188
#, c-format
msgid "%d signatures not checked due to missing keys\n"
msgstr "%d firmas no comprobadas por falta de clave\n"
#: g10/keyedit.c:190
msgid "1 signature not checked due to an error\n"
msgstr "1 firma no comprobada por causa de un error\n"
#: g10/keyedit.c:192
#, c-format
msgid "%d signatures not checked due to errors\n"
msgstr "%d firmas no comprobadas por causa de un error\n"
#: g10/keyedit.c:194
msgid "1 user id without valid self-signature detected\n"
msgstr "Detectado 1 id de usuario sin autofirma válida\n"
#: g10/keyedit.c:196
#, c-format
msgid "%d user ids without valid self-signatures detected\n"
msgstr "Detectados %d ids de usuario sin autofirma válida\n"
#: g10/keyedit.c:258
#, c-format
msgid "Already signed by key %08lX\n"
msgstr "Ya firmada por la clave %08lX\n"
#: g10/keyedit.c:266
#, c-format
msgid "Nothing to sign with key %08lX\n"
msgstr "Nada que firmar con la clave %08lX\n"
#: g10/keyedit.c:275
msgid ""
"Are you really sure that you want to sign this key\n"
"with your key: \""
msgstr ""
"¿Está realmente seguro de querer firmar esta clave\n"
"con su clave: \""
#: g10/keyedit.c:282
msgid "Really sign? "
msgstr "¿Firmar de verdad? "
#: g10/keyedit.c:303 g10/sign.c:65
#, c-format
msgid "signing failed: %s\n"
msgstr "firma fallida: %s\n"
#: g10/keyedit.c:356
msgid "This key is not protected.\n"
msgstr "Esta clave no está protegida.\n"
#: g10/keyedit.c:359
msgid "Key is protected.\n"
msgstr "La clave está protegida.\n"
#: g10/keyedit.c:376
#, c-format
msgid "Can't edit this key: %s\n"
msgstr "No puede editarse esta clave: %s\n"
#: g10/keyedit.c:381
msgid ""
"Enter the new passphrase for this secret key.\n"
"\n"
msgstr ""
"Introduzca la nueva contraseña para esta clave secreta.\n"
"\n"
#: g10/keyedit.c:393
msgid ""
"You don't want a passphrase - this is probably a *bad* idea!\n"
"\n"
msgstr ""
"No ha especificado contraseña. Esto es probablemente una *mala* idea.\n"
"\n"
#: g10/keyedit.c:396
msgid "Do you really want to do this? "
msgstr "¿Realmente quiere hacer esto? "
#: g10/keyedit.c:455
msgid "moving a key signature to the correct place\n"
msgstr ""
#: g10/keyedit.c:490
msgid "quit"
msgstr ""
#: g10/keyedit.c:490
msgid "quit this menu"
msgstr "sale de este menú"
#: g10/keyedit.c:491
msgid "q"
msgstr ""
#: g10/keyedit.c:492
msgid "save"
msgstr ""
#: g10/keyedit.c:492
msgid "save and quit"
msgstr "graba y sale"
#: g10/keyedit.c:493
msgid "help"
msgstr ""
#: g10/keyedit.c:493
msgid "show this help"
msgstr "muestra esta ayuda"
#: g10/keyedit.c:495
msgid "fpr"
msgstr ""
#: g10/keyedit.c:495
msgid "show fingerprint"
msgstr "muestra huella digital"
#: g10/keyedit.c:496
msgid "list"
msgstr ""
#: g10/keyedit.c:496
msgid "list key and user ids"
msgstr "lista clave e identificativos de usuario"
#: g10/keyedit.c:497
msgid "l"
msgstr ""
#: g10/keyedit.c:498
msgid "uid"
msgstr ""
#: g10/keyedit.c:498
msgid "select user id N"
msgstr "selecciona identificativo de usuario N"
#: g10/keyedit.c:499
msgid "key"
msgstr ""
#: g10/keyedit.c:499
msgid "select secondary key N"
msgstr "selecciona clave secundaria N"
#: g10/keyedit.c:500
msgid "check"
msgstr ""
#: g10/keyedit.c:500
msgid "list signatures"
msgstr "lista firmas"
#: g10/keyedit.c:501
msgid "c"
msgstr ""
#: g10/keyedit.c:502
msgid "sign"
msgstr ""
#: g10/keyedit.c:502
msgid "sign the key"
msgstr "firma la clave"
#: g10/keyedit.c:503
msgid "s"
msgstr ""
#: g10/keyedit.c:504
msgid "debug"
msgstr ""
#: g10/keyedit.c:505
msgid "adduid"
msgstr ""
#: g10/keyedit.c:505
msgid "add a user id"
msgstr "añade un identificativo de usuario"
#: g10/keyedit.c:506
msgid "deluid"
msgstr ""
#: g10/keyedit.c:506
msgid "delete user id"
msgstr "borra un identificativo de usuario"
#: g10/keyedit.c:507
msgid "addkey"
msgstr ""
#: g10/keyedit.c:507
msgid "add a secondary key"
msgstr "añade una clave secundaria"
#: g10/keyedit.c:508
msgid "delkey"
msgstr ""
#: g10/keyedit.c:508
msgid "delete a secondary key"
msgstr "borra una clave secundaria"
#: g10/keyedit.c:509
msgid "expire"
msgstr ""
#: g10/keyedit.c:509
msgid "change the expire date"
msgstr "cambia fecha de caducidad"
#: g10/keyedit.c:510
msgid "toggle"
msgstr ""
#: g10/keyedit.c:510
msgid "toggle between secret and public key listing"
msgstr "cambia entre lista de claves secretas y públicas"
#: g10/keyedit.c:512
msgid "t"
msgstr ""
#: g10/keyedit.c:513
msgid "pref"
msgstr ""
#: g10/keyedit.c:513
msgid "list preferences"
msgstr "muestra preferencias"
#: g10/keyedit.c:514
msgid "passwd"
msgstr ""
#: g10/keyedit.c:514
msgid "change the passphrase"
msgstr "cambia la contraseña"
#: g10/keyedit.c:515
msgid "trust"
msgstr ""
#: g10/keyedit.c:515
msgid "change the ownertrust"
msgstr "cambia valores de confianza"
#: g10/keyedit.c:534
msgid "can't do that in batchmode\n"
msgstr "imposible hacer esto en modo de proceso por lotes\n"
#. check that they match
#. FIXME: check that they both match
#: g10/keyedit.c:561
msgid "Secret key is available.\n"
msgstr "Clave secreta disponible.\n"
#: g10/keyedit.c:590
msgid "Command> "
msgstr "Comando> "
#: g10/keyedit.c:617
msgid "Need the secret key to do this.\n"
msgstr "Se necesita la clave secreta para hacer esto\n"
#: g10/keyedit.c:639
msgid "Save changes? "
msgstr "¿Grabar cambios? "
#: g10/keyedit.c:642
msgid "Quit without saving? "
msgstr "¿Salir sin grabar? "
#: g10/keyedit.c:652
#, c-format
msgid "update failed: %s\n"
msgstr "actualización fallida: %s\n"
#: g10/keyedit.c:659
#, c-format
msgid "update secret failed: %s\n"
msgstr "actualización de la clave secreta fallida: %s\n"
#: g10/keyedit.c:666
msgid "Key not changed so no update needed.\n"
msgstr "Clave sin cambios, no se necesita actualización.\n"
#: g10/keyedit.c:669 g10/keyedit.c:727
#, c-format
msgid "update of trust db failed: %s\n"
msgstr "actualización de confianza fallida: %s\n"
#: g10/keyedit.c:701
msgid "Really sign all user ids? "
msgstr "¿Firmar realmente todos los identificativos de usuario? "
#: g10/keyedit.c:702
msgid "Hint: Select the user ids to sign\n"
msgstr "Sugerencia: seleccione los identificativos de usuario a firmar\n"
#: g10/keyedit.c:738
msgid "You must select at least one user id.\n"
msgstr "Debe seleccionar por lo menos un identificativo de usuario.\n"
#: g10/keyedit.c:740
msgid "You can't delete the last user id!\n"
msgstr "¡No puede borrar el último identificativo de usuario!\n"
#: g10/keyedit.c:743
msgid "Really remove all selected user ids? "
msgstr "¿Borrar realmente todos los identificativos seleccionados? "
#: g10/keyedit.c:744
msgid "Really remove this user id? "
msgstr "¿Borrar realmente este identificativo? "
#: g10/keyedit.c:767
msgid "You must select at least one key.\n"
msgstr "Debe seleccionar por lo menos una clave.\n"
#: g10/keyedit.c:771
msgid "Do you really want to delete the selected keys? "
msgstr "¿Borrar realmente las claves seleccionadas? "
#: g10/keyedit.c:772
msgid "Do you really want to delete this key? "
msgstr "¿Borrar realmente esta clave? "
#: g10/keyedit.c:819
msgid "Invalid command (try \"help\")\n"
msgstr "Comando no válido (pruebe \"help\")\n"
#: g10/keyedit.c:1197
msgid "Please remove selections from the secret keys.\n"
msgstr "Por favor, quite la selección de las claves secretas.\n"
#: g10/keyedit.c:1203
msgid "Please select at most one secondary key.\n"
msgstr "Por favor, seleccione como máximo una clave secundaria\n"
#: g10/keyedit.c:1207
msgid "Changing exiration time for a secondary key.\n"
msgstr "Cambiando caducidad de clave secundaria.\n"
#: g10/keyedit.c:1209
msgid "Changing exiration time for the primary key.\n"
msgstr "Cambiando caducidad de clave primaria.\n"
#: g10/keyedit.c:1250
msgid "You can't change the expiration date of a v3 key\n"
msgstr ""
#: g10/keyedit.c:1266
msgid "No corresponding signature in secret ring\n"
msgstr "No hay firma correspondiente en anillo secreto\n"
#: g10/keyedit.c:1326
#, c-format
msgid "No user id with index %d\n"
msgstr "No hay ningún identificativo de usuario con el índice %d\n"
#: g10/keyedit.c:1371
#, c-format
msgid "No secondary key with index %d\n"
msgstr "No hay ninguna clave secundaria con el índice %d\n"
#: g10/mainproc.c:198
#, fuzzy
msgid "public key encrypted data: Good DEK\n"
msgstr "descifrado de la clave pública fallido: %s\n"
#: g10/mainproc.c:201
#, c-format
msgid "public key decryption failed: %s\n"
msgstr "descifrado de la clave pública fallido: %s\n"
#: g10/mainproc.c:228
#, fuzzy
msgid "decryption okay\n"
msgstr "descifrado fallido: %s\n"
#: g10/mainproc.c:231
#, c-format
msgid "decryption failed: %s\n"
msgstr "descifrado fallido: %s\n"
#: g10/mainproc.c:248
#, fuzzy
msgid "NOTE: sender requested \"for-your-eyes-only\"\n"
msgstr "nota: el remitente solicitó \"sólo-para-tus-ojos\"\n"
#: g10/mainproc.c:250
#, c-format
msgid "original file name='%.*s'\n"
msgstr ""
#: g10/mainproc.c:833
msgid "signature verification suppressed\n"
msgstr ""
#: g10/mainproc.c:839
#, c-format
msgid "Signature made %.*s using %s key ID %08lX\n"
msgstr "Firma creada %.*s usando identificativo de clave %08lX\n"
#: g10/mainproc.c:847
msgid "BAD signature from \""
msgstr "Firma INCORRECTA de \""
#: g10/mainproc.c:848
msgid "Good signature from \""
msgstr "Firma correcta de \""
#: g10/mainproc.c:861
#, c-format
msgid "Can't check signature: %s\n"
msgstr "Imposible comprobar la firma: %s\n"
#: g10/mainproc.c:934
msgid "old style (PGP 2.x) signature\n"
msgstr ""
#: g10/mainproc.c:939
msgid "invalid root packet detected in proc_tree()\n"
msgstr ""
#: g10/misc.c:88
#, fuzzy, c-format
msgid "can't disable core dumps: %s\n"
msgstr "no puede abrirse '%s': %s\n"
#: g10/misc.c:90
msgid "WARNING: Program may create a core file!\n"
msgstr ""
#: g10/misc.c:198
msgid "Experimental algorithms should not be used!\n"
msgstr ""
#: g10/misc.c:212
msgid ""
"RSA keys are deprecated; please consider creating a new key and use this key "
"in the future\n"
msgstr ""
"Las claves RSA están en desuso, considere la creación de una nueva clave "
"para futuros usos\n"
#: g10/misc.c:233
msgid "This cipher algorithm is depreciated; please use a more standard one!\n"
msgstr ""
#: g10/parse-packet.c:109
#, fuzzy, c-format
msgid "can't handle public key algorithm %d\n"
msgstr "no puede bloquearse el anillo público: %s\n"
#: g10/passphrase.c:141
msgid ""
"\n"
"You need a passphrase to unlock the secret key for\n"
"user: \""
msgstr ""
"\n"
"Necesita una contraseña para desbloquear la clave secreta\n"
"del usuario: \""
#: g10/passphrase.c:150
#, c-format
msgid "(%u-bit %s key, ID %08lX, created %s)\n"
msgstr "clave %2$s de %1$u bits, ID %3$08lX, creada el %4$s)\n"
#: g10/passphrase.c:174
#, fuzzy
msgid "Enter passphrase: "
msgstr "Introduzca contraseña: "
#: g10/passphrase.c:178
#, fuzzy
msgid "Repeat passphrase: "
msgstr "Repita contraseña: "
#: g10/plaintext.c:102
msgid "data not saved; use option \"--output\" to save it\n"
msgstr "datos no grabados; use la opción \"--output\" para grabarlos\n"
#: g10/plaintext.c:215
msgid "Please enter name of data file: "
msgstr "Introduzca el nombre del fichero de datos: "
#: g10/plaintext.c:236
msgid "reading stdin ...\n"
msgstr ""
#: g10/plaintext.c:299
#, c-format
msgid "can't open signed data '%s'\n"
msgstr "imposible abrir datos firmados '%s'\n"
#: g10/pubkey-enc.c:78
#, c-format
msgid "anonymous receiver; trying secret key %08lX ...\n"
msgstr "destinatario anónimo, probando clave secreta %08lX ...\n"
#: g10/pubkey-enc.c:84
msgid "okay, we are the anonymous receiver.\n"
msgstr "De acuerdo, somo el destinatario anónimo.\n"
#: g10/pubkey-enc.c:136
#, fuzzy
msgid "old encoding of the DEK is not supported\n"
msgstr "el algoritmo de protección %d no está soportado\n"
#: g10/pubkey-enc.c:183
#, fuzzy, c-format
msgid "NOTE: cipher algorithm %d not found in preferences\n"
msgstr "nota: algoritmo de cifrado %d no encontrado en las preferencias\n"
#: g10/seckey-cert.c:56
#, c-format
msgid "protection algorithm %d is not supported\n"
msgstr "el algoritmo de protección %d no está soportado\n"
#: g10/seckey-cert.c:169
msgid "Invalid passphrase; please try again ...\n"
msgstr "Contraseña incorrecta, inténtelo de nuevo...\n"
#: g10/seckey-cert.c:216
#, fuzzy
msgid "WARNING: Weak key detected - please change passphrase again.\n"
msgstr "Aviso: detectada clave débil - por favor cambie la contraseña.\n"
#: g10/sig-check.c:155
msgid ""
"this is a PGP generated ElGamal key which is NOT secure for signatures!\n"
msgstr ""
"¡esto es una clave ElGamal generada por PGP que NO es segura para las "
"firmas!\n"
#: g10/sig-check.c:165
msgid "public key created in future (time warp or clock problem)\n"
msgstr ""
"clave pública creada en el futuro (salto en el tiempo o problemas con el "
"reloj)\n"
#: g10/sig-check.c:170
#, fuzzy, c-format
msgid "NOTE: signature key expired %s\n"
msgstr "atención: firma de la clave caducada el %s\n"
#: g10/sign.c:69
#, fuzzy, c-format
msgid "%s signature from: %s\n"
msgstr "Firma INCORRECTA de \""
#: g10/sign.c:200 g10/sign.c:564
#, fuzzy, c-format
msgid "can't create %s: %s\n"
msgstr "no puede abrirse '%s': %s\n"
#: g10/sign.c:296
msgid "signing:"
msgstr ""
#: g10/sign.c:336
#, fuzzy, c-format
msgid "WARNING: '%s' is an empty file\n"
msgstr "%s: atención: fichero vacío\n"
#: g10/tdbio.c:116 g10/tdbio.c:1413
#, fuzzy, c-format
msgid "trustdb rec %lu: lseek failed: %s\n"
msgstr "actualización de la clave secreta fallida: %s\n"
#: g10/tdbio.c:122 g10/tdbio.c:1420
#, c-format
msgid "trustdb rec %lu: write failed (n=%d): %s\n"
msgstr ""
#: g10/tdbio.c:232
msgid "trustdb transaction to large\n"
msgstr ""
#: g10/tdbio.c:402
#, fuzzy, c-format
msgid "%s: can't access: %s\n"
msgstr "%s: no puede abrirse: %s\n"
#: g10/ringedit.c:273 g10/tdbio.c:422
#, fuzzy, c-format
msgid "%s: can't create directory: %s\n"
msgstr "%s: no puede abrirse: %s\n"
#: g10/ringedit.c:279 g10/tdbio.c:425
#, c-format
msgid "%s: directory created\n"
msgstr ""
#: g10/tdbio.c:429
#, c-format
msgid "%s: directory does not exist!\n"
msgstr ""
#: g10/openfile.c:101 g10/openfile.c:165 g10/ringedit.c:1256 g10/tdbio.c:435
#, fuzzy, c-format
msgid "%s: can't create: %s\n"
msgstr "%s: no puede abrirse: %s\n"
#: g10/tdbio.c:459
#, c-format
msgid "%s: failed to create version record: %s"
msgstr ""
#: g10/tdbio.c:463
#, c-format
msgid "%s: invalid trust-db created\n"
msgstr ""
#: g10/tdbio.c:465
#, c-format
msgid "%s: trust-db created\n"
msgstr ""
#: g10/tdbio.c:506
#, c-format
msgid "%s: invalid trust-db\n"
msgstr ""
#: g10/tdbio.c:540
#, c-format
msgid "%s: failed to create hashtable: %s\n"
msgstr ""
#: g10/tdbio.c:548
#, fuzzy, c-format
msgid "%s: error updating version record: %s\n"
msgstr "%s: error comprobando la clave: %s\n"
#: g10/tdbio.c:564 g10/tdbio.c:603 g10/tdbio.c:628 g10/tdbio.c:1346
#: g10/tdbio.c:1373
#, fuzzy, c-format
msgid "%s: error reading version record: %s\n"
msgstr "%s: error comprobando la clave: %s\n"
#: g10/tdbio.c:577
#, fuzzy, c-format
msgid "%s: error writing version record: %s\n"
msgstr "%s: error comprobando la clave: %s\n"
#: g10/tdbio.c:1053
#, fuzzy, c-format
msgid "trustdb: lseek failed: %s\n"
msgstr "actualización de la clave secreta fallida: %s\n"
#: g10/tdbio.c:1061
#, fuzzy, c-format
msgid "trustdb: read failed (n=%d): %s\n"
msgstr "actualización de confianza fallida: %s\n"
#: g10/tdbio.c:1082
#, fuzzy, c-format
msgid "%s: not a trustdb file\n"
msgstr "actualización de confianza fallida: %s\n"
#: g10/tdbio.c:1098
#, c-format
msgid "%s: version record with recnum %lu\n"
msgstr ""
#: g10/tdbio.c:1103
#, fuzzy, c-format
msgid "%s: invalid file version %d\n"
msgstr "cabecera de firma clara no válida\n"
#: g10/tdbio.c:1379
#, fuzzy, c-format
msgid "%s: error reading free record: %s\n"
msgstr "%s: error comprobando la clave: %s\n"
#: g10/tdbio.c:1387
#, fuzzy, c-format
msgid "%s: error writing dir record: %s\n"
msgstr "%s: error comprobando la clave: %s\n"
#: g10/tdbio.c:1397
#, c-format
msgid "%s: failed to zero a record: %s\n"
msgstr ""
#: g10/tdbio.c:1427
#, c-format
msgid "%s: failed to append a record: %s\n"
msgstr ""
#: g10/trustdb.c:134
msgid "The trust DB is corrupted; please run \"gpgm --fix-trust-db\".\n"
msgstr ""
"La base de datos de confianza está dañada. Por favor, ejecute\n"
"\"gpgm --fix-trust-db\".\n"
#: g10/trustdb.c:147
#, c-format
msgid "trust record %lu, req type %d: read failed: %s\n"
msgstr ""
#: g10/trustdb.c:162
#, c-format
msgid "trust record %lu, type %d: write failed: %s\n"
msgstr ""
#: g10/trustdb.c:176
#, fuzzy, c-format
msgid "trust record %lu: delete failed: %s\n"
msgstr "actualización de la clave secreta fallida: %s\n"
#: g10/trustdb.c:190
#, fuzzy, c-format
msgid "trust db: sync failed: %s\n"
msgstr "actualización de confianza fallida: %s\n"
#: g10/trustdb.c:319
#, c-format
msgid "error reading dir record for LID %lu: %s\n"
msgstr ""
#: g10/trustdb.c:326
#, c-format
msgid "lid %lu: expected dir record, got type %d\n"
msgstr ""
#: g10/trustdb.c:331
#, c-format
msgid "no primary key for LID %lu\n"
msgstr ""
#: g10/trustdb.c:336
#, fuzzy, c-format
msgid "error reading primary key for LID %lu: %s\n"
msgstr "error creando contraseña: %s\n"
#: g10/trustdb.c:412
#, c-format
msgid "chained sigrec %lu has a wrong owner\n"
msgstr ""
#: g10/trustdb.c:455
#, fuzzy, c-format
msgid "'%s' is not a valid long keyID\n"
msgstr "Caracter no válido en el comentario\n"
#: g10/trustdb.c:490
#, fuzzy, c-format
msgid "key %08lX: no public key for trusted key - skipped\n"
msgstr "clave %08lX: clave secreta sin clave pública - ignorada\n"
#: g10/trustdb.c:499 g10/trustdb.c:557
#, c-format
msgid "key %08lX: can't put it into the trustdb\n"
msgstr "clave %08lX: imposible incluirla en la base de datos de confianza\n"
#: g10/trustdb.c:504 g10/trustdb.c:563
#, c-format
msgid "key %08lX: query record failed\n"
msgstr "clave %08lX: petición de registro fallida\n"
#: g10/trustdb.c:509 g10/trustdb.c:572
#, fuzzy, c-format
msgid "key %08lX: already in trusted key table\n"
msgstr "clave %08lX: ya está en la tabla secreta\n"
#: g10/trustdb.c:512 g10/trustdb.c:575
#, fuzzy, c-format
msgid "key %08lX: accepted as trusted key.\n"
msgstr "clave %08lX: aceptada como clave secreta.\n"
#: g10/trustdb.c:528
#, fuzzy, c-format
msgid "NOTE: secret key %08lX is NOT protected.\n"
msgstr "Esta clave no está protegida.\n"
#: g10/trustdb.c:540
#, c-format
msgid "key %08lX: secret key without public key - skipped\n"
msgstr "clave %08lX: clave secreta sin clave pública - ignorada\n"
#: g10/trustdb.c:547
#, c-format
msgid "key %08lX: secret and public key don't match\n"
msgstr "clave %08lX: las claves pública y secreta no se corresponden\n"
#: g10/trustdb.c:583
#, fuzzy, c-format
msgid "enumerate secret keys failed: %s\n"
msgstr "enum_secret_keys fallido: %s\n"
#: g10/trustdb.c:766
#, fuzzy, c-format
msgid "lid %lu: read dir record failed: %s\n"
msgstr "clave %08lX: inserción del registro de confianza fallida: %s\n"
#: g10/trustdb.c:775
#, fuzzy, c-format
msgid "lid %lu: read key record failed: %s\n"
msgstr "clave %08lX: inserción del registro de confianza fallida: %s\n"
#: g10/trustdb.c:785
#, fuzzy, c-format
msgid "lid %lu: read uid record failed: %s\n"
msgstr "clave %08lX: inserción del registro de confianza fallida: %s\n"
#: g10/trustdb.c:794
#, fuzzy, c-format
msgid "lid %lu: read pref record failed: %s\n"
msgstr "clave %08lX: inserción del registro de confianza fallida: %s\n"
#: g10/trustdb.c:804
#, fuzzy, c-format
msgid "lid %lu: read sig record failed: %s\n"
msgstr "clave %08lX: inserción del registro de confianza fallida: %s\n"
#: g10/trustdb.c:999
msgid "Ooops, no keys\n"
msgstr ""
#: g10/trustdb.c:1003
#, fuzzy
msgid "Ooops, no user ids\n"
msgstr "lista clave e identificativos de usuario"
#: g10/trustdb.c:1074 g10/trustdb.c:1092
#, c-format
msgid "user '%s' read problem: %s\n"
msgstr ""
#: g10/trustdb.c:1077 g10/trustdb.c:1095
#, c-format
msgid "user '%s' list problem: %s\n"
msgstr ""
#: g10/trustdb.c:1085 g10/trustdb.c:1300
#, fuzzy, c-format
msgid "user '%s' not found: %s\n"
msgstr "%s: usuario no encontrado\n"
#: g10/trustdb.c:1087 g10/trustdb.c:1302
#, c-format
msgid "problem finding '%s' in trustdb: %s\n"
msgstr ""
#: g10/trustdb.c:1090
#, c-format
msgid "user '%s' not in trustdb\n"
msgstr ""
#: g10/trustdb.c:1125
#, c-format
msgid ""
"# List of assigned trustvalues, created %s\n"
"# (Use \"gpgm --import-ownertrust\" to restore them)\n"
msgstr ""
#: g10/trustdb.c:1131
msgid "directory record w/o primary key\n"
msgstr ""
#: g10/trustdb.c:1138
#, fuzzy, c-format
msgid "error reading key record: %s\n"
msgstr "%s: error comprobando la clave: %s\n"
#: g10/trustdb.c:1178
-msgid "line to long\n"
+msgid "line too long\n"
msgstr ""
#: g10/trustdb.c:1186
msgid "error: missing colon\n"
msgstr ""
#: g10/trustdb.c:1191
#, fuzzy
msgid "error: invalid fingerprint\n"
msgstr "muestra huella digital"
#: g10/trustdb.c:1195
#, fuzzy
msgid "error: no ownertrust value\n"
msgstr "exporta los valores de confianza"
#: g10/trustdb.c:1209
#, c-format
msgid "LID %lu: changing trust from %u to %u\n"
msgstr ""
#: g10/trustdb.c:1212
#, c-format
msgid "LID %lu: setting trust to %u\n"
msgstr ""
#: g10/trustdb.c:1220
msgid "key not in trustdb, searching ring.\n"
msgstr ""
#: g10/trustdb.c:1223
#, fuzzy, c-format
msgid "key not in ring: %s\n"
msgstr "no puede escribirse el anillo: %s\n"
#: g10/trustdb.c:1227
msgid "Oops: key is now in trustdb???\n"
msgstr ""
#. update the ownertrust
#: g10/trustdb.c:1232
#, fuzzy, c-format
msgid "insert trust record failed: %s\n"
msgstr "clave %08lX: inserción del registro de confianza fallida: %s\n"
#. error
#: g10/trustdb.c:1238
#, fuzzy, c-format
msgid "error finding dir record: %s\n"
msgstr "eliminación de armadura fallida: %s\n"
#: g10/trustdb.c:1305
#, c-format
msgid "user '%s' not in trustdb - inserting\n"
msgstr ""
#: g10/trustdb.c:1308
#, fuzzy, c-format
msgid "failed to put '%s' into trustdb: %s\n"
msgstr "inicialización de la base de datos de confianza '%s' fallida\n"
#: g10/trustdb.c:1355
#, c-format
msgid "%s: keyblock read problem: %s\n"
msgstr ""
#: g10/trustdb.c:1369
#, fuzzy, c-format
msgid "%s: update failed: %s\n"
msgstr "actualización fallida: %s\n"
#: g10/trustdb.c:1372
#, c-format
msgid "%s: updated\n"
msgstr ""
#: g10/trustdb.c:1374
#, c-format
msgid "%s: okay\n"
msgstr ""
#: g10/trustdb.c:1389
#, c-format
msgid "lid %lu: dir record w/o key - skipped\n"
msgstr ""
#: g10/trustdb.c:1402
#, fuzzy, c-format
msgid "lid %lu: keyblock not found: %s\n"
msgstr "clave %08lX: clave pública no encontrada: %s\n"
#: g10/trustdb.c:1411 g10/trustdb.c:1480
#, fuzzy, c-format
msgid "lid %lu: update failed: %s\n"
msgstr "actualización fallida: %s\n"
#: g10/trustdb.c:1417 g10/trustdb.c:1486
#, c-format
msgid "lid %lu: updated\n"
msgstr ""
#: g10/trustdb.c:1421 g10/trustdb.c:1490
#, c-format
msgid "lid %lu: okay\n"
msgstr ""
#: g10/trustdb.c:1428 g10/trustdb.c:1496
#, c-format
msgid "%lu keys processed\n"
msgstr ""
#: g10/trustdb.c:1430
#, fuzzy, c-format
msgid "\t%lu keys skipped\n"
msgstr "%s: ignorado: %s\n"
#: g10/trustdb.c:1432 g10/trustdb.c:1498
#, fuzzy, c-format
msgid "\t%lu keys with errors\n"
msgstr "Error de escritura"
#: g10/trustdb.c:1434 g10/trustdb.c:1500
#, c-format
msgid "\t%lu keys updated\n"
msgstr ""
#: g10/trustdb.c:1464
#, fuzzy, c-format
msgid "lid ?: insert failed: %s\n"
msgstr "actualización de la clave secreta fallida: %s\n"
#: g10/trustdb.c:1469
#, fuzzy, c-format
msgid "lid %lu: insert failed: %s\n"
msgstr "actualización de la clave secreta fallida: %s\n"
#: g10/trustdb.c:1475
#, c-format
msgid "lid %lu: inserted\n"
msgstr ""
#: g10/trustdb.c:1502
#, c-format
msgid "\t%lu keys inserted\n"
msgstr ""
#: g10/trustdb.c:1505
#, fuzzy, c-format
msgid "enumerate keyblocks failed: %s\n"
msgstr "enum_secret_keys fallido: %s\n"
#: g10/trustdb.c:1550
#, fuzzy, c-format
msgid "check_trust: search dir record failed: %s\n"
msgstr "clave %08lX: inserción del registro de confianza fallida: %s\n"
#: g10/trustdb.c:1557
#, c-format
msgid "key %08lX: insert trust record failed: %s\n"
msgstr "clave %08lX: inserción del registro de confianza fallida: %s\n"
#: g10/trustdb.c:1561
#, c-format
msgid "key %08lX.%lu: inserted into trustdb\n"
msgstr "clave %08lX.%lu: incluida en la base de datos de confianza\n"
#: g10/trustdb.c:1569
#, c-format
msgid "key %08lX.%lu: created in future (time warp or clock problem)\n"
msgstr ""
"clave %08lX.%lu: creada en el futuro (salto en el tiempo o\n"
"problemas con el reloj)\n"
#: g10/trustdb.c:1576
#, c-format
msgid "key %08lX.%lu: expired at %s\n"
msgstr "clave %08lX.%lu: caducada el %s\n"
#: g10/trustdb.c:1584
#, c-format
msgid "key %08lX.%lu: trust check failed: %s\n"
msgstr "clave %08lX.%lu: comprobación de confianza fallida: %s\n"
#: g10/trustdb.c:1753 g10/trustdb.c:1782 g10/trustdb.c:2521
msgid "WARNING: can't yet handle long pref records\n"
msgstr ""
#: g10/trustdb.c:1804
#, fuzzy, c-format
msgid "get_dir_record: search_record failed: %s\n"
msgstr "actualización de la clave secreta fallida: %s\n"
#: g10/trustdb.c:1867
#, c-format
msgid "NOTE: sig rec %lu[%d] in hintlist of %lu but marked as checked\n"
msgstr ""
#: g10/trustdb.c:1871
#, c-format
msgid "NOTE: sig rec %lu[%d] in hintlist of %lu but not marked\n"
msgstr ""
#. we need the dir record
#: g10/trustdb.c:1878
#, c-format
msgid "sig rec %lu[%d] in hintlist of %lu does not point to a dir record\n"
msgstr ""
#: g10/trustdb.c:1884
#, c-format
msgid "lid %lu: no primary key\n"
msgstr ""
#: g10/trustdb.c:1917
#, c-format
msgid "lid %lu: user id not found in keyblock\n"
msgstr ""
#: g10/trustdb.c:1921
#, fuzzy, c-format
msgid "lid %lu: user id without signature\n"
msgstr "clave %08lX: no hay id de usuario para la firma\n"
#: g10/trustdb.c:1928
#, c-format
msgid "lid %lu: self-signature in hintlist\n"
msgstr ""
#: g10/trustdb.c:1939 g10/trustdb.c:2658 g10/trustdb.c:2742
#, fuzzy
msgid "Valid certificate revocation"
msgstr "Certificado incorrecto"
#: g10/trustdb.c:1940 g10/trustdb.c:2659 g10/trustdb.c:2743
#, fuzzy
msgid "Good certificate"
msgstr "Certificado incorrecto"
#: g10/trustdb.c:1949
msgid "very strange: no public key\n"
msgstr ""
#: g10/trustdb.c:1997
#, c-format
msgid "hintlist %lu[%d] of %lu does not point to a dir record\n"
msgstr ""
#: g10/trustdb.c:2003
#, c-format
msgid "lid %lu does not have a key\n"
msgstr ""
#: g10/trustdb.c:2013
#, c-format
msgid "lid %lu: can't get keyblock: %s\n"
msgstr ""
#: g10/trustdb.c:2070 g10/trustdb.c:2984
#, fuzzy, c-format
msgid "tdbio_search_dir failed: %s\n"
msgstr "eliminación de armadura fallida: %s\n"
#: g10/trustdb.c:2223
#, fuzzy, c-format
msgid "key %08lX.%lu: Good subkey binding\n"
msgstr "clave %08lX: no hay id de usuario\n"
#: g10/trustdb.c:2229 g10/trustdb.c:2271
#, fuzzy, c-format
msgid "key %08lX.%lu: Invalid subkey binding: %s\n"
msgstr "clave %08lX: no hay ids de usuario válidos\n"
#: g10/trustdb.c:2244
#, fuzzy, c-format
msgid "key %08lX.%lu: Valid key revocation\n"
msgstr "clave %08lX.%lu: caducada el %s\n"
#: g10/trustdb.c:2250
#, fuzzy, c-format
msgid "key %08lX.%lu: Invalid key revocation: %s\n"
msgstr "clave %08lX: clave pública no encontrada: %s\n"
#: g10/trustdb.c:2265
#, fuzzy, c-format
msgid "key %08lX.%lu: Valid subkey revocation\n"
msgstr "clave %08lX: no hay ids de usuario válidos\n"
#: g10/trustdb.c:2365
#, fuzzy
msgid "Good self-signature"
msgstr "[autofirma]"
#: g10/trustdb.c:2376
#, fuzzy
msgid "Invalid self-signature"
msgstr "clave %08lX: autofirma no válida\n"
#: g10/trustdb.c:2386
msgid "Valid user ID revocation skipped due to a newer self signature\n"
msgstr ""
#: g10/trustdb.c:2393
#, fuzzy
msgid "Valid user ID revocation\n"
msgstr "Elección no válida.\n"
#: g10/trustdb.c:2400
#, fuzzy
msgid "Invalid user ID revocation"
msgstr "Elección no válida.\n"
#: g10/trustdb.c:2484
#, fuzzy
msgid "Too many preferences"
msgstr "muestra preferencias"
#: g10/trustdb.c:2498
msgid "Too many preference items"
msgstr ""
#: g10/trustdb.c:2637
msgid "Duplicated certificate - deleted"
msgstr ""
#: g10/trustdb.c:2670
#, fuzzy
msgid "Hmmm, public key lost?"
msgstr "Clave pública incorrecta"
#: g10/trustdb.c:2680 g10/trustdb.c:2763
#, fuzzy
msgid "Invalid certificate revocation"
msgstr "Certificado incorrecto"
#: g10/trustdb.c:2681 g10/trustdb.c:2764
#, fuzzy
msgid "Invalid certificate"
msgstr "Certificado incorrecto"
#: g10/trustdb.c:2696
#, c-format
msgid "uid %08lX.%lu/%02X%02X: has shadow dir %lu but is not yet marked.\n"
msgstr ""
#: g10/trustdb.c:2710
#, c-format
msgid "sig record %lu[%d] points to wrong record.\n"
msgstr ""
#. that should never happen
#: g10/trustdb.c:2954
#, fuzzy, c-format
msgid "insert_trust_record: keyblock not found: %s\n"
msgstr "clave %08lX: clave secreta no encontrada: %s\n"
#: g10/trustdb.c:2972
msgid "did not use primary key for insert_trust_record()\n"
msgstr ""
#: g10/ringedit.c:293
#, fuzzy, c-format
msgid "%s: can't create keyring: %s\n"
msgstr "no puede escribirse el anillo: %s\n"
#: g10/ringedit.c:299 g10/ringedit.c:1264
#, c-format
msgid "%s: keyring created\n"
msgstr ""
#: g10/ringedit.c:1449
msgid "WARNING: 2 files with confidential information exists.\n"
msgstr ""
#: g10/ringedit.c:1450
#, c-format
msgid "%s is the unchanged one\n"
msgstr ""
#: g10/ringedit.c:1451
#, c-format
msgid "%s is the new one\n"
msgstr ""
#: g10/ringedit.c:1452
msgid "Please fix this possible security flaw\n"
msgstr ""
#: g10/skclist.c:94
#, fuzzy, c-format
msgid "skipped '%s': %s\n"
msgstr "%s: ignorado: %s\n"
#: g10/skclist.c:100
#, fuzzy, c-format
msgid ""
"skipped '%s': this is a PGP generated ElGamal key which is not secure for "
"signatures!\n"
msgstr ""
"¡esto es una clave ElGamal generada por PGP que NO es segura para las "
"firmas!\n"
#. do not overwrite
#: g10/openfile.c:58
#, c-format
msgid "File '%s' exists. "
msgstr "El fichero '%s' ya existe. "
#: g10/openfile.c:60
msgid "Overwrite (y/N)? "
msgstr "¿Sobreescribir (s/N)? "
#: g10/openfile.c:85
#, fuzzy
msgid "writing to stdout\n"
msgstr "escribiendo en '%s'\n"
#: g10/openfile.c:134
#, fuzzy, c-format
msgid "assuming signed data in '%s'\n"
msgstr "imposible abrir datos firmados '%s'\n"
#: g10/openfile.c:181
#, c-format
msgid "%s: new options file created\n"
msgstr ""
#: g10/encr-data.c:59
#, fuzzy, c-format
msgid "%s encrypted data\n"
msgstr "cifra datos"
#: g10/encr-data.c:61
#, c-format
msgid "encrypted with unknown algorithm %d\n"
msgstr ""
#: g10/encr-data.c:74
#, fuzzy
msgid ""
"WARNING: Message was encrypted with a weak key in the symmetric cipher.\n"
msgstr ""
"Atención: mensaje cifrado con una clave débil en el cifrado simétrico.\n"
#: g10/seskey.c:52
msgid "weak key created - retrying\n"
msgstr "creada clave débil - reintentando\n"
#: g10/seskey.c:57
#, c-format
msgid "cannot avoid weak key for symmetric cipher; tried %d times!\n"
msgstr ""
"¡imposible evitar clave débil para cifrado simétrico después de %d "
"intentos!\n"
#. begin of list
#: g10/helptext.c:45
msgid "edit_ownertrust.value"
msgstr ""
#: g10/helptext.c:51
msgid "revoked_key.override"
msgstr ""
#: g10/helptext.c:55
msgid "untrusted_key.override"
msgstr ""
#: g10/helptext.c:59
msgid "pklist.user_id.enter"
msgstr ""
#: g10/helptext.c:63
msgid "keygen.algo"
msgstr ""
#: g10/helptext.c:79
msgid "keygen.algo.elg_se"
msgstr ""
#: g10/helptext.c:86
msgid "keygen.size"
msgstr ""
#: g10/helptext.c:90
msgid "keygen.size.huge.okay"
msgstr ""
#: g10/helptext.c:95
msgid "keygen.size.large.okay"
msgstr ""
#: g10/helptext.c:100
msgid "keygen.valid"
msgstr ""
#: g10/helptext.c:104
msgid "keygen.valid.okay"
msgstr ""
#: g10/helptext.c:109
msgid "keygen.name"
msgstr ""
#: g10/helptext.c:114
msgid "keygen.email"
msgstr ""
#: g10/helptext.c:118
msgid "keygen.comment"
msgstr ""
#: g10/helptext.c:123
msgid "keygen.userid.cmd"
msgstr ""
#: g10/helptext.c:132
msgid "keygen.sub.okay"
msgstr ""
#: g10/helptext.c:136
msgid "sign_uid.okay"
msgstr ""
#: g10/helptext.c:141
msgid "change_passwd.empty.okay"
msgstr ""
#: g10/helptext.c:146
msgid "keyedit.cmd"
msgstr ""
#: g10/helptext.c:150
msgid "keyedit.save.okay"
msgstr ""
#: g10/helptext.c:155
msgid "keyedit.cancel.okay"
msgstr ""
#: g10/helptext.c:159
msgid "keyedit.sign_all.okay"
msgstr ""
#: g10/helptext.c:163
msgid "keyedit.remove.uid.okay"
msgstr ""
#: g10/helptext.c:168
msgid "keyedit.remove.subkey.okay"
msgstr ""
#: g10/helptext.c:172
msgid "passphrase.enter"
msgstr ""
#: g10/helptext.c:179
msgid "passphrase.repeat"
msgstr ""
#: g10/helptext.c:183
msgid "detached_signature.filename"
msgstr ""
#: g10/helptext.c:187
msgid "openfile.overwrite.okay"
msgstr ""
#: g10/helptext.c:201
msgid "No help available"
msgstr "Ayuda no disponible"
#: g10/helptext.c:213
#, c-format
msgid "No help available for '%s'"
msgstr "Ayuda no disponible para '%s'"
#~ msgid "You will see a list of signators etc. here\n"
#~ msgstr "Aquí se verá una lista de firmantes, etc.\n"
#~ msgid "key %08lX.%lu, uid %02X%02X, sig %08lX: good signature (3)\n"
#~ msgstr "clave %08lX.%lu, uid %02X%02X, firma %08lX: firma correcta (3)\n"
#~ msgid ""
#~ "key %08lX.%lu, uid %02X%02X, sig %08lX: very strange: no public key\n"
#~ msgstr ""
#~ "clave %08lX.%lu, uid %02X%02X, firma %08lX: extraño, no hay clave pública\n"
#~ msgid "key %08lX.%lu, uid %02X%02X, sig %08lX: invalid signature: %s\n"
#~ msgstr "clave %08lX.%lu, uid %02X%02X, firma %08lX: firma incorrecta: %s\n"
#~ msgid "key %08lX.%lu, uid %02X%02X: good self-signature\n"
#~ msgstr "clave %08lX.%lu, uid %02X%02X: autofirma correcta\n"
#~ msgid ""
#~ "key %08lX.%lu, uid %02X%02X, sig %08lX: duplicated signature - deleted\n"
#~ msgstr ""
#~ "clave %08lX.%lu, uid %02X%02X, firma %08lX: firma duplicada - borrada\n"
#~ msgid "key %08lX.%lu, uid %02X%02X, sig %08lX: good signature (1)\n"
#~ msgstr "clave %08lX.%lu, uid %02X%02X, firma %08lX: firma correcta (1)\n"
#~ msgid "key %08lX.%lu, uid %02X%02X, sig %08lX: weird: no public key\n"
#~ msgstr ""
#~ "clave %08lX.%lu, uid %02X%02X, firma %08lX: raro, no hay clave pública\n"
#~ msgid "key %08lX.%lu, uid %02X%02X, sig %08lX: good signature (2)\n"
#~ msgstr "clave %08lX.%lu, uid %02X%02X, firma %08lX: firma correcta (2)\n"
#~ msgid "key %08lX.%lu, uid %02X%02X, sig %08lX: no public key\n"
#~ msgstr "clave %08lX.%lu, uid %02X%02X, firma %08lX: no hay clave pública\n"
diff --git a/po/fr.po b/po/fr.po
index 95cacdce5..dbc8e415b 100644
--- a/po/fr.po
+++ b/po/fr.po
@@ -1,3145 +1,3123 @@
# GnuPG french translation
# Copyright (C) 1998 Free Software Foundation, Inc.
# Gaël Quéri <gqueri@mail.dotcom.fr>, 1998.
#
msgid ""
msgstr ""
-"Project-Id-Version: gnupg-0.4.1a\n"
-"POT-Creation-Date: 1998-12-10 20:11+0100\n"
-"PO-Revision-Date: 1998-10-29 19:01+0100\n"
+"Project-Id-Version: gnupg 0.4.5a\n"
+"POT-Creation-Date: 1998-12-15 00:29+0100\n"
+"PO-Revision-Date: 1998-12-15 00:35+01:00\n"
"Last-Translator: Gaël Quéri <gqueri@mail.dotcom.fr>\n"
"Language-Team: French <fr@li.org>\n"
"MIME-Version: 1.0\n"
-"Content-Type: text/plain; charset=iso8859-1\n"
+"Content-Type: text/plain; charset=ISO-8859-1\n"
"Content-Transfer-Encoding: 8-bit\n"
#: util/secmem.c:77
msgid "Warning: using insecure memory!\n"
-msgstr "Attention: utilisation de la mémoire non sûre!\n"
+msgstr "Attention : utilisation de la mémoire non sûre !\n"
#: util/miscutil.c:143
msgid "yes"
msgstr "oui"
#: util/miscutil.c:144
msgid "yY"
msgstr "oO"
#: util/errors.c:54
msgid "General error"
-msgstr "Erreur Générale"
+msgstr "Erreur générale"
#: util/errors.c:55
msgid "Unknown packet type"
msgstr "Type de paquet inconnu"
#: util/errors.c:56
msgid "Unknown version"
msgstr "Version inconnue"
#: util/errors.c:57
msgid "Unknown pubkey algorithm"
msgstr "Algorithme de clé publique inconnu"
#: util/errors.c:58
msgid "Unknown digest algorithm"
msgstr "Algorithme de hachage inconnu"
#: util/errors.c:59
msgid "Bad public key"
msgstr "Mauvaise clé publique"
#: util/errors.c:60
msgid "Bad secret key"
msgstr "Mauvaise clé secrète"
#: util/errors.c:61
msgid "Bad signature"
msgstr "Mauvaise signature"
#: util/errors.c:62
msgid "Checksum error"
-msgstr "Erreur de somme de vérification"
+msgstr "Erreur de checksum"
#: util/errors.c:63
msgid "Bad passphrase"
msgstr "Mauvais mot de passe"
#: util/errors.c:64
msgid "Public key not found"
msgstr "Clé publique non trouvée"
#: util/errors.c:65
msgid "Unknown cipher algorithm"
msgstr "Algorithme de chiffrement inconnu"
#: util/errors.c:66
msgid "Can't open the keyring"
msgstr "Ne peut ouvrir le porte-clés"
#: util/errors.c:67
msgid "Invalid packet"
msgstr "Paquet invalide"
#: util/errors.c:68
msgid "Invalid armor"
msgstr "Armure invalide"
#: util/errors.c:69
msgid "No such user id"
-msgstr "Pas de tel utilisateur."
+msgstr "Pas de tel utilisateur"
#: util/errors.c:70
msgid "Secret key not available"
-msgstr "La clé secrète n'est pas disponible."
+msgstr "La clé secrète n'est pas disponible"
#: util/errors.c:71
msgid "Wrong secret key used"
msgstr "Mauvaise clé secrète utilisée"
#: util/errors.c:72
msgid "Not supported"
msgstr "Non supporté"
#: util/errors.c:73
msgid "Bad key"
msgstr "Mauvaise clé"
#: util/errors.c:74
msgid "File read error"
msgstr "Erreur de lecture"
#: util/errors.c:75
msgid "File write error"
msgstr "Erreur d'écriture"
#: util/errors.c:76
msgid "Unknown compress algorithm"
msgstr "Algorithme de compression inconnu"
#: util/errors.c:77
msgid "File open error"
msgstr "Erreur d'ouverture de fichier"
#: util/errors.c:78
msgid "File create error"
msgstr "Erreur de création de fichier"
#: util/errors.c:79
msgid "Invalid passphrase"
msgstr "Mot de passe invalide"
#: util/errors.c:80
msgid "Unimplemented pubkey algorithm"
msgstr "Algorithme de clé publique non implémenté"
#: util/errors.c:81
msgid "Unimplemented cipher algorithm"
msgstr "Algorithme de chiffrement non implémenté"
#: util/errors.c:82
msgid "Unknown signature class"
msgstr "Classe de signature inconnue"
#: util/errors.c:83
msgid "Trust database error"
msgstr "Erreur dans la base de confiance"
#: util/errors.c:84
msgid "Bad MPI"
-msgstr "Mauvais MPI"
+msgstr "Mauvais entier en précision multiple"
#: util/errors.c:85
msgid "Resource limit"
msgstr "Limite de ressources"
#: util/errors.c:86
msgid "Invalid keyring"
msgstr "Porte-clés invalide"
#: util/errors.c:87
msgid "Bad certificate"
msgstr "Mauvais certificat"
#: util/errors.c:88
msgid "Malformed user id"
-msgstr "Nom d'utilisateur déformé"
+msgstr "Nom d'utilisateur malformé"
#: util/errors.c:89
msgid "File close error"
msgstr "Erreur de fermeture de fichier"
#: util/errors.c:90
msgid "File rename error"
msgstr "Erreur pendant le changement de nom du fichier"
#: util/errors.c:91
msgid "File delete error"
msgstr "Erreur pendant la suppression du fichier"
#: util/errors.c:92
msgid "Unexpected data"
msgstr "Données inattendues"
#: util/errors.c:93
msgid "Timestamp conflict"
msgstr "Conflit de dates"
#: util/errors.c:94
msgid "Unusable pubkey algorithm"
msgstr "Algorithme de clés publiques inutilisable"
#: util/errors.c:95
msgid "File exists"
msgstr "Le fichier existe"
#: util/errors.c:96
msgid "Weak key"
msgstr "Mauvaise clé"
#: util/logger.c:178
#, c-format
msgid "... this is a bug (%s:%d:%s)\n"
msgstr "... c'est un bug (%s:%d:%s)\n"
#: util/logger.c:184
#, c-format
msgid "you found a bug ... (%s:%d)\n"
msgstr "vous avez trouvé un bug ... (%s:%d)\n"
-#: cipher/random.c:412
-#, fuzzy
+#: cipher/random.c:406
msgid "WARNING: using insecure random number generator!!\n"
msgstr ""
-"attention: utilisation d'un générateur de nombres aléatoires peu sûr!!\n"
+"ATTENTION : utilisation d'un générateur de nombres aléatoires peu sûr !!\n"
-#: cipher/random.c:413
+#: cipher/random.c:407
msgid ""
"The random number generator is only a kludge to let\n"
"it run - it is in no way a strong RNG!\n"
"\n"
"DON'T USE ANY DATA GENERATED BY THIS PROGRAM!!\n"
"\n"
msgstr ""
-"Le générateur de nombres aléatoires n'est qu'un artifice visant\n"
-"à le compiler - ce n'est en aucune manière un générateur(RNG) fort!\n"
+"Le générateur de nombres aléatoires n'est qu'un artifice visant à exécuter\n"
+"GnuPG - ce n'est en aucune manière un générateur (RNG) fort!\n"
"\n"
"N'UTILISEZ PAS LES DONNÉES GÉNÉRÉES PAR CE PROGRAMME!!\n"
"\n"
-#: cipher/rndlinux.c:116
+#: cipher/rndlinux.c:118
#, c-format
msgid ""
"\n"
"Not enough random bytes available. Please do some other work to give\n"
"the OS a chance to collect more entropy! (Need %d more bytes)\n"
msgstr ""
"\n"
"Il n'y a pas assez d'octets aléatoires disponibles. Faites autre chose\n"
-"pour que l'OS puisse amasser plus d'entropie! (il faut %d octets de plus)\n"
+"pour que l'OS puisse amasser plus d'entropie ! (il faut %d octets de plus)\n"
#: g10/g10.c:159
msgid ""
"@Commands:\n"
" "
msgstr ""
"@Commandes:\n"
" "
#: g10/g10.c:162
msgid "|[file]|make a signature"
msgstr "|[fichier]|faire une signature"
#: g10/g10.c:163
msgid "|[file]|make a clear text signature"
msgstr "|[fichier]|faire une signature en texte clair"
#: g10/g10.c:164
msgid "make a detached signature"
msgstr "faire une signature détachée"
#: g10/g10.c:165
msgid "encrypt data"
-msgstr "crypter les données"
+msgstr "chiffrer les données"
#: g10/g10.c:166
msgid "encryption only with symmetric cipher"
-msgstr "chiffrement symétrique seumement"
+msgstr "chiffrement symétrique seulement"
#: g10/g10.c:167
msgid "store only"
msgstr "pas d'action"
#: g10/g10.c:168
msgid "decrypt data (default)"
-msgstr "décrypter les données (défaut)"
+msgstr "déchiffrer les données (défaut)"
#: g10/g10.c:169
msgid "verify a signature"
msgstr "vérifier une signature"
#: g10/g10.c:171
msgid "list keys"
msgstr "lister les clés"
#: g10/g10.c:172
msgid "list keys and signatures"
msgstr "lister les clés et les signatures"
#: g10/g10.c:173
msgid "check key signatures"
msgstr "vérifier les signatures des clés"
#: g10/g10.c:174
msgid "list keys and fingerprints"
msgstr "lister les clés et les empreintes"
#: g10/g10.c:175
msgid "list secret keys"
msgstr "lister les clés secrètes"
#: g10/g10.c:177
msgid "generate a new key pair"
msgstr "générer une nouvelle paire de clés"
#: g10/g10.c:179
msgid "remove key from the public keyring"
msgstr "enlever la clé du porte-clés public"
#: g10/g10.c:181
msgid "sign or edit a key"
msgstr "signer ou éditer une clé"
#: g10/g10.c:182
msgid "generate a revocation certificate"
msgstr "générer un certificat de révocation"
#: g10/g10.c:184
msgid "export keys"
msgstr "exporter les clés"
#: g10/g10.c:187
msgid "import/merge keys"
msgstr "importer/fusionner les clés"
#: g10/g10.c:189
msgid "list only the sequence of packets"
-msgstr "ne lister qu'une suite de paquets"
+msgstr "ne lister que les paquets"
#: g10/g10.c:192
msgid "export the ownertrust values"
-msgstr "exporter les valeurs de confiance"
+msgstr "exporter les indices de confiance"
#: g10/g10.c:194
msgid "import ownertrust values"
-msgstr "importer les valeurs de confiance"
+msgstr "importer les indices de confiance"
#
#: g10/g10.c:196
msgid "|[NAMES]|update the trust database"
msgstr "|[NOMS]|mettre la base de confiance à jour"
#: g10/g10.c:198
msgid "|[NAMES]|check the trust database"
msgstr "|[NOMS]|vérifier la base de confiance"
#: g10/g10.c:199
msgid "fix a corrupted trust database"
msgstr "réparer une base de confiance corrompue"
#: g10/g10.c:200
msgid "De-Armor a file or stdin"
msgstr "Enlever l'armure d'un fichier ou de stdin"
#: g10/g10.c:201
msgid "En-Armor a file or stdin"
msgstr "Mettre une armure à un fichier ou à stdin"
#: g10/g10.c:202
msgid "|algo [files]|print message digests"
msgstr "|alg. [fich.]|indiquer les fonctions de hachage"
#: g10/g10.c:203
msgid "print all message digests"
msgstr "écrire toutes les fonctions de hachage"
#: g10/g10.c:210
msgid ""
"@\n"
"Options:\n"
" "
msgstr ""
"@\n"
"Options:\n"
" "
#: g10/g10.c:212
msgid "create ascii armored output"
msgstr "créer une sortie ascii armurée"
#: g10/g10.c:214
msgid "use this user-id to sign or decrypt"
-msgstr "utiliser ce nom pour signer ou décrypter"
+msgstr "utiliser ce nom pour signer ou déchiffrer"
#: g10/g10.c:215
msgid "use this user-id for encryption"
-msgstr "utiliser ce nom d'utilisateur pour crypter"
+msgstr "utiliser ce nom d'utilisateur pour chiffrer"
#: g10/g10.c:216
msgid "|N|set compress level N (0 disables)"
msgstr "|N|niveau de compression N (0 désactive)"
#: g10/g10.c:218
msgid "use canonical text mode"
msgstr "utiliser le mode de texte canonique"
#: g10/g10.c:220
msgid "use as output file"
msgstr "utiliser comme fichier de sortie"
#: g10/g10.c:221
msgid "verbose"
msgstr "bavard"
#: g10/g10.c:222
msgid "be somewhat more quiet"
msgstr "devenir beaucoup plus silencieux"
#
#: g10/g10.c:223
msgid "force v3 signatures"
msgstr "forcer les signatures en v3"
#. { oDryRun, "dry-run", 0, N_("do not make any changes") },
#: g10/g10.c:225
msgid "batch mode: never ask"
-msgstr "mode automatique: ne jamais rien demander"
+msgstr "mode automatique : ne jamais rien demander"
#: g10/g10.c:226
msgid "assume yes on most questions"
-msgstr "supposer oui à la plupart des questions"
+msgstr "répondre oui à la plupart des questions"
#: g10/g10.c:227
msgid "assume no on most questions"
-msgstr "supposer non à la plupart des questions"
+msgstr "répondre non à la plupart des questions"
#: g10/g10.c:228
msgid "add this keyring to the list of keyrings"
msgstr "ajouter ce porte-clés à la liste des porte-clés"
#: g10/g10.c:229
msgid "add this secret keyring to the list"
msgstr "ajouter ce porte-clés secret à la liste"
#: g10/g10.c:230
msgid "|NAME|use NAME as default secret key"
msgstr "|NOM|utiliser NOM comme clé secrète par défaut"
#: g10/g10.c:231
-#, fuzzy
msgid "|NAME|set terminal charset to NAME"
-msgstr "|NOM|utiliser l'algorithme de cryptage NOM"
+msgstr "|NOM|le terminal utilise la table de caractères NOM"
#: g10/g10.c:232
msgid "read options from file"
msgstr "lire les options du fichier"
#: g10/g10.c:234
msgid "set debugging flags"
msgstr "choisir les attributs de déboguage"
#: g10/g10.c:235
msgid "enable full debugging"
msgstr "permettre un déboguage complet"
#: g10/g10.c:236
msgid "|FD|write status info to this FD"
-msgstr "|FD|écrire les informations d'état sur ce descripteur"
+msgstr "|FD|écrire l'état sur ce descripteur"
#: g10/g10.c:237
msgid "do not write comment packets"
msgstr "ne pas écrire de paquets de commentaire"
#: g10/g10.c:238
msgid "(default is 1)"
msgstr "(1 par défaut)"
#: g10/g10.c:239
msgid "(default is 3)"
msgstr "(3 par défaut)"
#: g10/g10.c:241
msgid "|KEYID|ulimately trust this key"
-msgstr ""
+msgstr "|IDCLE|donner une confiance totale à cette clé"
#: g10/g10.c:242
msgid "|FILE|load extension module FILE"
msgstr "|FICH|charger le module d'extension FICH"
#: g10/g10.c:243
msgid "emulate the mode described in RFC1991"
-msgstr "émuler le mode décrit dans la RFC1991"
+msgstr "imiter le mode décrit dans la RFC1991"
+# FIXMOI : faudra trouver mieux ...
#: g10/g10.c:244
msgid "|N|use passphrase mode N"
msgstr "|N|utiliser le mode de mots de passe N"
#: g10/g10.c:246
msgid "|NAME|use message digest algorithm NAME for passphrases"
msgstr "|NOM|utiliser le hachage NOM pour les mots de passe"
#: g10/g10.c:248
msgid "|NAME|use cipher algorithm NAME for passphrases"
-msgstr "|NOM|utiliser le cryptage NOM pour les mots de passe"
+msgstr "|NOM|utiliser le chiffrement NOM pour les mots de passe"
#: g10/g10.c:250
msgid "|NAME|use cipher algorithm NAME"
-msgstr "|NOM|utiliser l'algorithme de cryptage NOM"
+msgstr "|NOM|utiliser l'algorithme de chiffrement NOM"
#: g10/g10.c:251
msgid "|NAME|use message digest algorithm NAME"
msgstr "|NOM|utiliser la fonction de hachage NOM"
#: g10/g10.c:252
msgid "|N|use compress algorithm N"
msgstr "|N|utiliser l'algorithme de compression N"
#: g10/g10.c:253
msgid "throw keyid field of encrypted packets"
-msgstr "enlever l'identification des paquets cryptés"
+msgstr "supprimer l'identification des paquets chiffrés"
#: g10/g10.c:261
msgid ""
"@\n"
"Examples:\n"
"\n"
" -se -r Bob [file] sign and encrypt for user Bob\n"
" --clearsign [file] make a clear text signature\n"
" --detach-sign [file] make a detached signature\n"
" --list-keys [names] show keys\n"
" --fingerprint [names] show fingerprints\n"
msgstr ""
"@\n"
"Exemples:\n"
"\n"
" -se -r Alice [fichier] signer et crypter pour l'utilisateur Alice\n"
" --clearsign [fichier] faire une signature en texte clair\n"
" --detach-sign [fichier] faire une signature détachée\n"
" --list-keys [utilisateur] montrer les clés\n"
" --fingerprint [utilisateur] montrer les empreintes\n"
#: g10/g10.c:339
msgid "Please report bugs to <gnupg-bugs@gnu.org>.\n"
msgstr "Rapporter toutes anomalies à <gnupg-bugs@gnu.org>.\n"
#: g10/g10.c:344
msgid "Usage: gpgm [options] [files] (-h for help)"
msgstr "Utilisation: gpgm [options] [fichiers] (-h pour l'aide)"
#: g10/g10.c:346
msgid "Usage: gpg [options] [files] (-h for help)"
msgstr "Utilisation: gpg [options] [fichiers] (-h pour l'aide)"
#
#: g10/g10.c:351
msgid ""
"Syntax: gpgm [options] [files]\n"
"GnuPG maintenance utility\n"
msgstr ""
"Syntaxe: gpgm [options] [fichiers]\n"
"utilitaire de maitenance de GnuPG\n"
#: g10/g10.c:354
msgid ""
"Syntax: gpg [options] [files]\n"
"sign, check, encrypt or decrypt\n"
"default operation depends on the input data\n"
msgstr ""
"Syntaxe: gpg [options] [fichiers]\n"
"signer, vérifier, crypter ou décrypter\n"
"l'opération par défaut dépend des données entrées\n"
#: g10/g10.c:360
msgid ""
"\n"
"Supported algorithms:\n"
msgstr ""
"\n"
"Algorithmes supportés:\n"
#: g10/g10.c:435
msgid "usage: gpgm [options] "
msgstr "utilisation: gpgm [options] "
#: g10/g10.c:437
msgid "usage: gpg [options] "
msgstr "utilisation: gpg [options] "
#: g10/g10.c:478
msgid "conflicting commands\n"
msgstr "commandes en conflit\n"
#: g10/g10.c:616
-#, fuzzy, c-format
+#, c-format
msgid "NOTE: no default option file '%s'\n"
-msgstr "note: pas de fichier d'options par défaut '%s'\n"
+msgstr "NOTE : pas de fichier d'options par défaut '%s'\n"
#: g10/g10.c:620
#, c-format
msgid "option file '%s': %s\n"
msgstr "fichier d'options '%s' : %s\n"
#: g10/g10.c:627
#, c-format
msgid "reading options from '%s'\n"
msgstr "lire les options de '%s'\n"
#: g10/g10.c:776
-#, fuzzy, c-format
+#, c-format
msgid "%s is not a valid character set\n"
-msgstr "Caractère invalide dans le commentaire\n"
+msgstr "%s n'est pas une table de caractères valide\n"
#: g10/g10.c:810 g10/g10.c:822
msgid "selected cipher algorithm is invalid\n"
-msgstr "l'algorithme de cryptage sélectionné est invalide\n"
+msgstr "l'algorithme de chiffrement sélectionné est invalide\n"
#: g10/g10.c:816 g10/g10.c:828
msgid "selected digest algorithm is invalid\n"
msgstr "la fonction de hachage sélectionnée est invalide\n"
#: g10/g10.c:831
#, c-format
msgid "compress algorithm must be in range %d..%d\n"
msgstr "l'algorithme de compression doit faire partie de l'échelle %d..%d\n"
#: g10/g10.c:833
msgid "completes-needed must be greater than 0\n"
-msgstr "le nombre de signatures complètes minimal doit être supérieur à 0\n"
+msgstr "« completes-needed » doit être supérieur à 0\n"
#: g10/g10.c:835
msgid "marginals-needed must be greater than 1\n"
-msgstr "le nombre de singatures marginales minimal doit être supérieur à 1\n"
+msgstr "« marginals-needed » doit être supérieur à 1\n"
#: g10/g10.c:837
msgid "max-cert-depth must be in range 1 to 255\n"
-msgstr ""
+msgstr "« max-cert-depth » doit être compris entre 1 et 255\n"
#: g10/g10.c:840
-#, fuzzy
msgid "NOTE: simple S2K mode (0) is strongly discouraged\n"
-msgstr "note: le mode S2K simple (0) est fortement déconseillé\n"
+msgstr "NOTE : le mode S2K simple (0) est fortement déconseillé\n"
#: g10/g10.c:844
msgid "invalid S2K mode; must be 0, 1 or 3\n"
-msgstr "mode S2K invalide; doit être 0, 1 ou 3\n"
+msgstr "mode S2K invalide ; doit être 0, 1 ou 3\n"
#: g10/g10.c:927
#, c-format
msgid "failed to initialize the TrustDB: %s\n"
-msgstr "n'a pas pu initialiser la base de confiance: %s\n"
+msgstr "n'a pas pu initialiser la base de confiance : %s\n"
#: g10/g10.c:933
msgid "--store [filename]"
msgstr "--store [nom du fichier]"
#: g10/g10.c:941
msgid "--symmetric [filename]"
msgstr "--symmetric [nom du fichier]"
#: g10/g10.c:949
msgid "--encrypt [filename]"
msgstr "--encrypt [nom du fichier]"
#: g10/g10.c:962
msgid "--sign [filename]"
msgstr "--sign [nom du fichier]"
#: g10/g10.c:975
msgid "--sign --encrypt [filename]"
msgstr "--sign --encrypt [nom du fichier]"
#: g10/g10.c:989
msgid "--clearsign [filename]"
msgstr "--clearsign [nom du fichier]"
#: g10/g10.c:1001
msgid "--decrypt [filename]"
msgstr "--decrypt [nom du fichier]"
#: g10/g10.c:1010
-#, fuzzy
msgid "--edit-key username [commands]"
-msgstr "--edit-key utilisateur"
+msgstr "--edit-key utilisateur [commandes]"
#: g10/g10.c:1026
msgid "--delete-secret-key username"
msgstr "--delete-secret-key utilisateur"
#: g10/g10.c:1029
msgid "--delete-key username"
msgstr "--delete-key utilisateur"
#: g10/encode.c:216 g10/g10.c:1052 g10/sign.c:301
#, c-format
msgid "can't open %s: %s\n"
msgstr "ne peut ouvrir %s: %s\n"
#: g10/g10.c:1063
msgid "-k[v][v][v][c] [userid] [keyring]"
msgstr "-k[v][v][v][c] [utilisateur] [porte-clés]"
#: g10/g10.c:1120
#, c-format
msgid "dearmoring failed: %s\n"
-msgstr "suppression d'armure non réussie: %s\n"
+msgstr "suppression d'armure non réussie : %s\n"
#: g10/g10.c:1128
#, c-format
msgid "enarmoring failed: %s\n"
-msgstr "mise d'armure non réussie:%s \n"
+msgstr "construction d'armure non réussie : %s \n"
#: g10/g10.c:1194
#, c-format
msgid "invalid hash algorithm '%s'\n"
-msgstr "algorithme de hachage invalide '%s'\n"
+msgstr "algorithme de hachage '%s' invalide\n"
#: g10/g10.c:1273
msgid "[filename]"
msgstr "[nom du fichier]"
#: g10/g10.c:1277
msgid "Go ahead and type your message ...\n"
-msgstr ""
+msgstr "Continuez et tapez votre message...\n"
#: g10/decrypt.c:59 g10/g10.c:1280 g10/verify.c:66
#, c-format
msgid "can't open '%s'\n"
msgstr "ne peut ouvrir '%s'\n"
#: g10/armor.c:344 g10/armor.c:391
msgid "armor header: "
-msgstr "entête d'armure: "
+msgstr "en-tête d'armure : "
#: g10/armor.c:355
msgid "invalid clearsig header\n"
-msgstr "entête de signature claire invalide\n"
+msgstr "en-tête de signature claire invalide\n"
#: g10/armor.c:382
msgid "invalid armor header: "
-msgstr "entête d'armure invalide: "
+msgstr "en-tête d'armure invalide : "
#: g10/armor.c:460
#, c-format
msgid "armor: %s\n"
-msgstr "armure: %s\n"
+msgstr "armure : %s\n"
#: g10/armor.c:533
msgid "invalid dash escaped line: "
-msgstr "ligne d'échappement invalide: "
+msgstr "ligne de traits d'échappement invalide : "
#: g10/armor.c:602
msgid "invalid clear text header: "
-msgstr "entête de texte clair invalide: "
+msgstr "en-tête de texte clair invalide : "
#: g10/armor.c:845
#, c-format
msgid "invalid radix64 character %02x skipped\n"
-msgstr "caractère %02x invalide en base 64 sauté\n"
+msgstr "caractère %02x invalide en base 64 ignoré\n"
#: g10/armor.c:878
msgid "premature eof (no CRC)\n"
msgstr "fin de fichier prématurée (pas de CRC)\n"
#: g10/armor.c:897
msgid "premature eof (in CRC)\n"
msgstr "fin de fichier prématurée (dans le CRC)\n"
#: g10/armor.c:901
msgid "malformed CRC\n"
msgstr "CRC malformé\n"
#: g10/armor.c:905
#, c-format
msgid "CRC error; %06lx - %06lx\n"
-msgstr "Erreur de CRC; 06lx - %06lx\n"
+msgstr "Erreur de CRC ; %06lx - %06lx\n"
#: g10/armor.c:924
msgid "premature eof (in Trailer)\n"
msgstr "fin de fichier prématurée (dans la remorque)\n"
#: g10/armor.c:928
msgid "error in trailer line\n"
msgstr "erreur dans la ligne de remorque\n"
#: g10/armor.c:1182
msgid "no valid RFC1991 or OpenPGP data found.\n"
msgstr "pas de donnée RFC1991 ou OpenPGP valide trouvée.\n"
#: g10/pkclist.c:121
-#, fuzzy, c-format
+#, c-format
msgid ""
"No trust value assigned to %lu:\n"
"%4u%c/%08lX %s \""
msgstr ""
-"Pas de confiance définie pour %lu:\n"
-"%4u%c/%08lX %s"
+"Pas de confiance définie pour %lu :\n"
+"%4u%c/%08lX %s \""
#: g10/pkclist.c:131
msgid ""
"Please decide how far you trust this user to correctly\n"
"verify other users' keys (by looking at passports,\n"
"checking fingerprints from different sources...)?\n"
"\n"
" 1 = Don't know\n"
" 2 = I do NOT trust\n"
" 3 = I trust marginally\n"
" 4 = I trust fully\n"
" s = please show me more information\n"
msgstr ""
"Décidez à quel point vous avez confiance en cet utilisateur pour vérifier\n"
"correctement les clés des autres utilisateurs (en regardant des passeports,\n"
"en vérifiant les empreintes de diverses sources...)?\n"
"\n"
-" 1 = Je ne sais pas\n"
-" 2 = Je ne lui fais pas confiance\n"
-" 3 = Je le crois marginalement\n"
-" 4 = Je le crois entièrement\n"
+" 1 = je ne sais pas\n"
+" 2 = je ne lui fais pas confiance\n"
+" 3 = je le crois marginalement\n"
+" 4 = je le crois totalement\n"
" s = montrez moi plus d'informations\n"
#: g10/pkclist.c:140
msgid " m = back to the main menu\n"
msgstr " m = retour au menu principal\n"
#. a string with valid answers
#: g10/pkclist.c:145
msgid "sSmM"
msgstr "sSmM"
#: g10/pkclist.c:149
msgid "Your decision? "
-msgstr "Votre décision? "
+msgstr "Votre décision ? "
#: g10/pkclist.c:169
msgid "Certificates leading to an ultimately trusted key:\n"
-msgstr ""
+msgstr "Certificats conduisant vers une clé à confiance ultime :\n"
#: g10/pkclist.c:197
msgid ""
"Could not find a valid trust path to the key. Let's see whether we\n"
"can assign some missing owner trust values.\n"
"\n"
msgstr ""
"N'a pas pu trouver un chemin de confiance valide jusqu'à la clé. Voyons si\n"
-"nous ne pouvons pas assigner quelques valeurs de confiance.\n"
+"nous ne pouvons pas assigner quelques indices de confiance manquants.\n"
#: g10/pkclist.c:219
msgid ""
"No path leading to one of our keys found.\n"
"\n"
msgstr ""
+"Aucun chemin menant vers une de nos clés n'a été trouvé.\n"
+"\n"
#: g10/pkclist.c:221
msgid ""
"No certificates with undefined trust found.\n"
"\n"
msgstr ""
+"Aucun certificat à confiance indéfinie n'a été trouvé.\n"
+"\n"
#: g10/pkclist.c:223
-#, fuzzy
msgid ""
"No trust values changed.\n"
"\n"
msgstr ""
-"Pas de valeur de confiance changée.\n"
+"Pas d'indice de confiance changé.\n"
"\n"
#: g10/pkclist.c:238
-#, fuzzy, c-format
+#, c-format
msgid "key %08lX: key has been revoked!\n"
-msgstr "clé %08lX: acceptée comme clé secrète.\n"
+msgstr "clé %08lX : la clé a été révoquée !\n"
#: g10/pkclist.c:244 g10/pkclist.c:335
msgid "Use this key anyway? "
-msgstr "Utiliser cette clé quand-même? "
+msgstr "Utiliser cette clé quand-même ? "
#: g10/pkclist.c:266
-#, fuzzy, c-format
+#, c-format
msgid "%08lX: key has expired\n"
-msgstr "Note: Cette clé a expiré!\n"
+msgstr "%08lX : la clé a expiré\n"
#: g10/pkclist.c:272
#, c-format
msgid "%08lX: no info to calculate a trust probability\n"
-msgstr ""
+msgstr "%08lX : pas d'information pour calculer une probabilité de confiance\n"
#: g10/pkclist.c:288
-#, fuzzy, c-format
+#, c-format
msgid "%08lX: We do NOT trust this key\n"
-msgstr "ATTENTION: On ne fait PAS confiance à cette clé\n"
+msgstr "%08lX : Nous ne faisons PAS confiance à cette clé\n"
#: g10/pkclist.c:294
#, c-format
msgid ""
"%08lX: It is not sure that this key really belongs to the owner\n"
"but it is accepted anyway\n"
msgstr ""
+"%08lX : Il n'est pas sûr que cette clé appartient vraiment à son "
+"propriétaire\n"
+"mais elle est quand même acceptée\n"
#: g10/pkclist.c:300
msgid "This key probably belongs to the owner\n"
-msgstr ""
+msgstr "Cette clé appartient probablement à son propriétaire\n"
#: g10/pkclist.c:305
msgid "This key belongs to us\n"
-msgstr ""
+msgstr "Cette clé nous appartient\n"
#: g10/pkclist.c:330
msgid ""
"It is NOT certain that the key belongs to its owner.\n"
"If you *really* know what you are doing, you may answer\n"
"the next question with yes\n"
"\n"
msgstr ""
"Il n'est pas certain que la clé appartient à sos propriétaire.\n"
"Si vous savez *vraiment* ce que vous faites, vous pouvez répondre\n"
"oui à la prochaine question\n"
"\n"
#: g10/pkclist.c:339
msgid "WARNING: Using untrusted key!\n"
-msgstr "ATTENTION: Utilisation d'une clé sans confiance!\n"
+msgstr "ATTENTION : Utilisation d'une clé sans confiance !\n"
#: g10/pkclist.c:375
msgid "WARNING: This key has been revoked by its owner!\n"
-msgstr "ATTENTION: Cette clé à été révoquée par son propriétaire\n"
+msgstr "ATTENTION : Cette clé à été révoquée par son propriétaire !\n"
#: g10/pkclist.c:376
msgid " This could mean that the signature is forgery.\n"
msgstr " Cela pourrait signifier que la signature est fausse.\n"
#: g10/pkclist.c:397
msgid "Note: This key has expired!\n"
-msgstr "Note: Cette clé a expiré!\n"
+msgstr "Note : Cette clé a expiré !\n"
#: g10/pkclist.c:404
msgid "WARNING: This key is not certified with a trusted signature!\n"
msgstr ""
-"ATTENTION: Cette clé n'est pas certifiée avec une signature de confiance!\n"
+"ATTENTION : Cette clé n'est pas certifiée avec une signature de confiance !\n"
#: g10/pkclist.c:406
msgid ""
" There is no indication that the signature belongs to the owner.\n"
-msgstr " Rien ne dit que la signature appartient au propriétaire.\n"
+msgstr " Rien ne dit que la signature appartient à son propriétaire.\n"
#: g10/pkclist.c:421
msgid "WARNING: We do NOT trust this key!\n"
-msgstr "ATTENTION: On ne fait PAS confiance à cette clé\n"
+msgstr "ATTENTION : Nous ne faisons PAS confiance à cette clé !\n"
#: g10/pkclist.c:422
msgid " The signature is probably a FORGERY.\n"
msgstr " La signature est certainement FAUSSE.\n"
#: g10/pkclist.c:429
msgid ""
"WARNING: This key is not certified with sufficiently trusted signatures!\n"
msgstr ""
-"ATTENTION: Les signatures de cette clé n'ont pas une confiance suffisante!\n"
+"ATTENTION : Les signatures de cette clé n'ont pas une confiance suffisante "
+"!\n"
#: g10/pkclist.c:432
msgid " It is not certain that the signature belongs to the owner.\n"
msgstr ""
-" Il n'est pas sûr que la signature appartient au propriétaire.\n"
+" Il n'est pas sûr que la signature appartient à son propriétaire.\n"
#: g10/pkclist.c:477
msgid ""
"You did not specify a user ID. (you may use \"-r\")\n"
"\n"
msgstr ""
-"Vous n'avez pas spécifié un nom d'utilisateur. (vous pouvez utiliser "
+"Vous n'avez pas spécifié de nom d'utilisateur. (vous pouvez utiliser "
"\"-r\")\n"
+"\n"
#: g10/pkclist.c:482
msgid "Enter the user ID: "
-msgstr "Entrez le nom d'utilisateur: "
+msgstr "Entrez le nom d'utilisateur : "
#: g10/pkclist.c:493
msgid "No such user ID.\n"
msgstr "Pas de tel utilisateur.\n"
#: g10/pkclist.c:527 g10/pkclist.c:554
#, c-format
msgid "%s: skipped: %s\n"
-msgstr "%s: sauté: %s\n"
+msgstr "%s : ignoré : %s\n"
#: g10/pkclist.c:535
#, c-format
msgid "%s: error checking key: %s\n"
-msgstr "%s: erreur pendant la vérification de la clé: %s\n"
+msgstr "%s : erreur pendant la vérification de la clé : %s\n"
#: g10/pkclist.c:561
msgid "no valid addressees\n"
msgstr "pas de destinataire valide\n"
# g10/keygen.c:123 ???
#: g10/keygen.c:124
msgid "writing self signature\n"
msgstr "écriture de l'auto-signature\n"
# g10/keygen.c:161 ???
#: g10/keygen.c:162
msgid "writing key binding signature\n"
-msgstr "écriture de la signature de \"key-binding\"\n"
+msgstr "écriture de la signature de liaison\n"
#: g10/keygen.c:388
msgid "Please select what kind of key you want:\n"
-msgstr "Sélectionnez le type de clé désiré:\n"
+msgstr "Sélectionnez le type de clé désiré :\n"
#: g10/keygen.c:390
#, c-format
msgid " (%d) DSA and ElGamal (default)\n"
msgstr " (%d) DSA et ElGamal (défaut)\n"
#: g10/keygen.c:391
#, c-format
msgid " (%d) DSA (sign only)\n"
-msgstr " (%d) DSA (signature seulement)\n"
+msgstr " (%d) DSA (signature seule)\n"
#: g10/keygen.c:393
#, c-format
msgid " (%d) ElGamal (encrypt only)\n"
-msgstr " (%d) ElGamal (cryptage seulement)\n"
+msgstr " (%d) ElGamal (chiffrement seul)\n"
#: g10/keygen.c:394
#, c-format
msgid " (%d) ElGamal (sign and encrypt)\n"
-msgstr " (%d) ElGamal (signature et cryptage)\n"
+msgstr " (%d) ElGamal (signature et chiffrement)\n"
#: g10/keygen.c:396
#, c-format
msgid " (%d) ElGamal in a v3 packet\n"
msgstr " (%d) ElGamal dans un paquet v3\n"
#: g10/keygen.c:401
msgid "Your selection? "
-msgstr "Votre choix? "
+msgstr "Votre choix ? "
#: g10/keygen.c:411
-#, fuzzy
msgid "Do you really want to create a sign and encrypt key? "
-msgstr "Voulez-vous supprimer les clés sélectionnées? "
+msgstr "Voulez-vous vraiment créer une clé de signature et de chiffrement ? "
#: g10/keygen.c:432
msgid "Invalid selection.\n"
msgstr "Choix invalide.\n"
#: g10/keygen.c:444
#, c-format
msgid ""
"About to generate a new %s keypair.\n"
" minimum keysize is 768 bits\n"
" default keysize is 1024 bits\n"
" highest suggested keysize is 2048 bits\n"
msgstr ""
"Préparation à la génération d'une nouvelle paire de clés %s.\n"
" la taille minimale est 768 bits\n"
" la taille par défaut est 1024 bits\n"
" la taille maximale conseillée est 2048 bits\n"
#: g10/keygen.c:451
msgid "What keysize do you want? (1024) "
-msgstr "Quelle taille de clé désirez-vous? (1024) "
+msgstr "Quelle taille de clé désirez-vous ? (1024) "
#: g10/keygen.c:456
msgid "DSA only allows keysizes from 512 to 1024\n"
msgstr "DSA permet seulement des tailles comprises entre 512 et 1024\n"
#: g10/keygen.c:458
msgid "keysize too small; 768 is smallest value allowed.\n"
-msgstr "taille trop petite; 768 est la plus petite valeur permise.\n"
+msgstr "taille trop petite ; 768 est la plus petite valeur permise.\n"
#: g10/keygen.c:461
msgid ""
"Keysizes larger than 2048 are not suggested because\n"
"computations take REALLY long!\n"
msgstr ""
"Les tailles supérieures à 2048 ne sont pas conseillées car\n"
"les calculs sont VRAIMENT longs!\n"
#: g10/keygen.c:464
msgid "Are you sure that you want this keysize? "
-msgstr "Etes-vous sûr que vous voulez cette taille? "
+msgstr "Etes-vous sûr de vouloir cette taille ? "
#: g10/keygen.c:465
msgid ""
"Okay, but keep in mind that your monitor and keyboard radiation is also very "
"vulnerable to attacks!\n"
msgstr ""
"D'accord, mais n'oubliez pas que votre écran et les radiations du clavier "
"sont aussi très vulnérables aux attaques!\n"
#: g10/keygen.c:473
msgid "Do you really need such a large keysize? "
-msgstr "Avez-vous réellement besoin d'une taille aussi grande? "
+msgstr "Avez-vous réellement besoin d'une taille aussi grande ? "
#: g10/keygen.c:479
#, c-format
msgid "Requested keysize is %u bits\n"
msgstr "La taille demandée est %u bits\n"
#: g10/keygen.c:482 g10/keygen.c:486
#, c-format
msgid "rounded up to %u bits\n"
msgstr "arrondie à %u bits\n"
#: g10/keygen.c:499
msgid ""
"Please specify how long the key should be valid.\n"
" 0 = key does not expire\n"
" <n> = key expires in n days\n"
" <n>w = key expires in n weeks\n"
" <n>m = key expires in n months\n"
" <n>y = key expires in n years\n"
msgstr ""
"Spécifiez combien de temps cette clé devrait être valide.\n"
" 0 = la clé n'expire pas\n"
" <n> = la clé expire dans n jours\n"
" <n>w = la clé expire dans n semaines\n"
" <n>m = la clé expire dans n mois\n"
" <n>y = la clé expire dans n ans\n"
#: g10/keygen.c:514
msgid "Key is valid for? (0) "
-msgstr "La clé est valide pour? (0) "
+msgstr "La clé est valide pour ? (0) "
#: g10/keygen.c:525
msgid "invalid value\n"
msgstr "valeur invalide\n"
#: g10/keygen.c:530
msgid "Key does not expire at all\n"
msgstr "La clé n'expire pas du tout\n"
#. print the date when the key expires
#: g10/keygen.c:536
#, c-format
msgid "Key expires at %s\n"
msgstr "La clé expire le %s\n"
#: g10/keygen.c:542
msgid "Is this correct (y/n)? "
-msgstr "Est-ce correct (o/n)? "
+msgstr "Est-ce correct (o/n) ? "
#: g10/keygen.c:584
msgid ""
"\n"
"You need a User-ID to identify your key; the software constructs the user "
"id\n"
"from Real Name, Comment and Email Address in this form:\n"
" \"Heinrich Heine (Der Dichter) <heinrichh@duesseldorf.de>\"\n"
"\n"
msgstr ""
"\n"
-"Vous avez besoin d'un nom d'utilisateur pour identifier votre clé; le "
+"Vous avez besoin d'un nom d'utilisateur pour identifier votre clé ; le\n"
"programme le construit à partir du nom réel, d'un commentaire et d'une\n"
"adresse e-mail de cette manière:\n"
-" \"Heinrich Heine (Der Dichter) <heinrichh@duesseldorf.de\"\n"
+" « Heinrich Heine (Der Dichter) <heinrichh@duesseldorf.de> »\n"
"\n"
#: g10/keygen.c:595
msgid "Real name: "
-msgstr "Nom: "
+msgstr "Nom réel : "
#: g10/keygen.c:599
msgid "Invalid character in name\n"
msgstr "Caractère invalide dans le nom\n"
#: g10/keygen.c:601
msgid "Name may not start with a digit\n"
msgstr "Le nom ne doit pas commencer avec un chiffre\n"
+# ??? c'est de la discrimination...
#: g10/keygen.c:603
msgid "Name must be at least 5 characters long\n"
msgstr "Le nom doit faire au moins 5 caractères de long\n"
#: g10/keygen.c:611
msgid "Email address: "
-msgstr "Adresse e-mail: "
+msgstr "Adresse e-mail : "
#: g10/keygen.c:623
msgid "Not a valid email address\n"
msgstr "Ce n'est pas une adresse e-mail valide\n"
#: g10/keygen.c:631
msgid "Comment: "
-msgstr "Commentaire: "
+msgstr "Commentaire : "
#: g10/keygen.c:637
msgid "Invalid character in comment\n"
msgstr "Caractère invalide dans le commentaire\n"
#: g10/keygen.c:657
#, c-format
msgid ""
"You selected this USER-ID:\n"
" \"%s\"\n"
"\n"
msgstr ""
-"Vous avez sélectionné ce nom d'utilisateur:\n"
+"Vous avez sélectionné ce nom d'utilisateur :\n"
" \"%s\"\n"
"\n"
#: g10/keygen.c:660
msgid "NnCcEeOoQq"
msgstr "NnCcEeOoQq"
#: g10/keygen.c:670
msgid "Change (N)ame, (C)omment, (E)mail or (O)kay/(Q)uit? "
msgstr "Changer le (N)om, le (C)ommentaire, l'(E)-mail ou (O)K/(Q)uitter? "
#: g10/keygen.c:722
msgid ""
"You need a Passphrase to protect your secret key.\n"
"\n"
msgstr ""
"Vous avez besoin d'un mot de passe pour protéger votre clé secrète.\n"
"\n"
#: g10/keyedit.c:389 g10/keygen.c:730
msgid "passphrase not correctly repeated; try again.\n"
-msgstr "le mot de passe n'a pas été correctement répété; recommencez.\n"
+msgstr "le mot de passe n'a pas été identiquement répété ; recommencez.\n"
#: g10/keygen.c:736
msgid ""
"You don't want a passphrase - this is probably a *bad* idea!\n"
"I will do it anyway. You can change your passphrase at any time,\n"
"using this program with the option \"--edit-key\".\n"
"\n"
msgstr ""
-"Vous ne voulez pas de mot de passe - c'est sûrement une *mauvaise* idée!\n"
+"Vous ne voulez pas de mot de passe - c'est sûrement une *mauvaise* idée !\n"
"Je l'accepte quand-même. Vous pouvez changer votre mot de passe quand vous\n"
-"le désirez, en utilisant ce programme avec l'option \"--edit-key\".\n"
+"le désirez, en utilisant ce programme avec l'option « --edit-key ».\n"
"\n"
#: g10/keygen.c:757
msgid ""
"We need to generate a lot of random bytes. It is a good idea to perform\n"
"some other action (work in another window, move the mouse, utilize the\n"
"network and the disks) during the prime generation; this gives the random\n"
"number generator a better chance to gain enough entropy.\n"
msgstr ""
"Beaucoup d'octets aléatoires doivent être générés. Vous devriez\n"
-"faire autre chose (travailler dans une autre fenêtre, bouger la souris,\n"
-"utiliser le réseau et les disques) pendant la génération de nombres\n"
-"premiers; cela permet au générateur de nombres aléatoires de gagner assez\n"
-"d'entropie plus facilement.\n"
+"faire quelque-chose d'autre (travailler dans une autre fenêtre, bouger la\n"
+"souris, utiliser le réseau et les disques) pendant la génération de nombres\n"
+"premiers ; cela permet au générateur de nombres aléatoires d'obtenir une\n"
+"entropie suffisante plus facilement.\n"
#: g10/keygen.c:827
msgid "Key generation can only be used in interactive mode\n"
msgstr "La génération de clé ne peut être faite qu'en mode interactif\n"
#: g10/keygen.c:835
msgid "DSA keypair will have 1024 bits.\n"
msgstr "La paire de clés DSA fera 1024 bits.\n"
#: g10/keygen.c:841
msgid "Key generation cancelled.\n"
msgstr "La génération a été annulée.\n"
#: g10/keygen.c:851
#, c-format
msgid "writing public certificate to '%s'\n"
msgstr "écriture d'un certificat public à '%s'\n"
#: g10/keygen.c:852
#, c-format
msgid "writing secret certificate to '%s'\n"
msgstr "écriture d'un certificat secret à '%s'\n"
#: g10/keygen.c:929
msgid "public and secret key created and signed.\n"
msgstr "les clés publique et secrète ont été créées et signées.\n"
#: g10/keygen.c:931
msgid ""
"Note that this key cannot be used for encryption. You may want to use\n"
"the command \"--add-key\" to generate a secondary key for this purpose.\n"
msgstr ""
-"Notez que cette clé ne peut être utilisée pour crypter. Vous pouvez "
-"utiliser\n"
-"la commande \"--add-key\" pour générer une clé secondaire à cette fin.\n"
+"Notez que cette clé ne peut être utilisée pour chiffrer. Vous pouvez\n"
+"utiliser la commande « --add-key » pour générer une clé secondaire à\n"
+"cette fin.\n"
#: g10/keygen.c:945 g10/keygen.c:1030
#, c-format
msgid "Key generation failed: %s\n"
-msgstr "La génération de clé a échoué: %s\n"
+msgstr "La génération de clé a échoué : %s\n"
#: g10/keygen.c:1008
msgid "Really create? "
-msgstr "Créer vraiment? "
+msgstr "Créer vraiment ? "
#: g10/encode.c:88 g10/openfile.c:81 g10/openfile.c:158 g10/tdbio.c:445
#: g10/tdbio.c:504
#, c-format
msgid "%s: can't open: %s\n"
-msgstr "%s: ne peut ouvrir: %s\n"
+msgstr "%s : ne peut ouvrir : %s\n"
#: g10/encode.c:107
#, c-format
msgid "error creating passphrase: %s\n"
-msgstr "erreur pendant la création du mot de passe: %s\n"
+msgstr "erreur pendant la création du mot de passe : %s\n"
#: g10/encode.c:155 g10/encode.c:269
-#, fuzzy, c-format
+#, c-format
msgid "%s: WARNING: empty file\n"
-msgstr "%s: attention: fichier vide\n"
+msgstr "%s : ATTENTION : fichier vide\n"
#: g10/encode.c:222
#, c-format
msgid "reading from '%s'\n"
msgstr "lecture de '%s'\n"
#: g10/encode.c:397
-#, fuzzy, c-format
+#, c-format
msgid "%s/%s encrypted for: %s\n"
-msgstr "%s crypté pour: %s\n"
+msgstr "%s/%s chiffré pour : %s\n"
#: g10/export.c:114
-#, fuzzy, c-format
+#, c-format
msgid "%s: user not found: %s\n"
-msgstr "%s: utilisateur non trouvé\n"
+msgstr "%s : utilisateur non trouvé : %s\n"
#: g10/export.c:123
#, c-format
msgid "certificate read problem: %s\n"
-msgstr ""
+msgstr "problème lors de lecture du certificat : %s\n"
#: g10/export.c:132
-#, fuzzy, c-format
+#, c-format
msgid "key %08lX: not a rfc2440 key - skipped\n"
-msgstr "clé %08lX: clé secrète sans clé publique - non prise en compte\n"
+msgstr "clé %08lX : ce n'est pas une clé rfc2440 - ignorée\n"
#: g10/export.c:174
-#, fuzzy
msgid "WARNING: nothing exported\n"
-msgstr "ATTENTION: Utilisation d'une clé sans confiance!\n"
+msgstr "ATTENTION : rien n'a été exporté\n"
#: g10/getkey.c:164
msgid "too many entries in pk cache - disabled\n"
-msgstr ""
+msgstr "trop d'entrées dans le cache pk - désactivé\n"
#: g10/getkey.c:263
msgid "too many entries in unk cache - disabled\n"
-msgstr ""
+msgstr "trop d'entrées dans le cache unk - désactivé\n"
#: g10/getkey.c:989
#, c-format
msgid "using secondary key %08lX instead of primary key %08lX\n"
msgstr ""
"utilisation de la clé secondaire %08lX à la place de la clé\n"
"principale %08lX\n"
#: g10/import.c:129 g10/trustdb.c:1166
#, c-format
msgid "can't open file: %s\n"
-msgstr "ne peut ouvrir le fichier: %s\n"
+msgstr "ne peut ouvrir le fichier : %s\n"
#: g10/import.c:145
#, c-format
msgid "skipping block of type %d\n"
-msgstr "ne prend pas en compte le bloc du type %d\n"
+msgstr "ne prend pas en compte le bloc de type %d\n"
#: g10/import.c:152 g10/trustdb.c:1425 g10/trustdb.c:1494
#, c-format
msgid "%lu keys so far processed\n"
msgstr "%lu clés traitées jusqu'ici\n"
#: g10/import.c:157 g10/trustdb.c:1242
#, c-format
msgid "read error: %s\n"
-msgstr "erreur de lecture: %s\n"
+msgstr "erreur de lecture : %s\n"
#: g10/import.c:159
#, c-format
msgid "Total number processed: %lu\n"
-msgstr " Quantité totale traitée: %lu\n"
+msgstr " Quantité totale traitée : %lu\n"
#: g10/import.c:161
#, c-format
msgid " w/o user IDs: %lu\n"
-msgstr " sans nom d'utilisateur: %lu\n"
+msgstr " sans nom d'utilisateur : %lu\n"
#: g10/import.c:163
#, c-format
msgid " imported: %lu"
-msgstr " importé: %lu"
+msgstr " importée : %lu"
#: g10/import.c:169
#, c-format
msgid " unchanged: %lu\n"
-msgstr " inchangé: %lu\n"
+msgstr " inchangée : %lu\n"
#: g10/import.c:171
#, c-format
msgid " new user IDs: %lu\n"
-msgstr " nouveaux noms d'utilisateur: %lu\n"
+msgstr " nouveaux noms d'utilisateurs : %lu\n"
#: g10/import.c:173
#, c-format
msgid " new subkeys: %lu\n"
-msgstr " nouvelles sous-clés: %lu\n"
+msgstr " nouvelles sous-clés : %lu\n"
#: g10/import.c:175
#, c-format
msgid " new signatures: %lu\n"
-msgstr " nouvelles signatures: %lu\n"
+msgstr " nouvelles signatures : %lu\n"
#: g10/import.c:177
#, c-format
msgid " new key revocations: %lu\n"
-msgstr " nouvelles révocations de clés: %lu\n"
+msgstr " nouvelles révocations de clés : %lu\n"
#: g10/import.c:179
#, c-format
msgid " secret keys read: %lu\n"
-msgstr " clés secrètes lues: %lu\n"
+msgstr " clés secrètes lues : %lu\n"
#: g10/import.c:181
#, c-format
msgid " secret keys imported: %lu\n"
-msgstr " clés secrètes importées: %lu\n"
+msgstr " clés secrètes importées : %lu\n"
#: g10/import.c:183
#, c-format
msgid " secret keys unchanged: %lu\n"
-msgstr " clés secrètes inchangées: %lu\n"
+msgstr " clés secrètes inchangées : %lu\n"
#: g10/import.c:325 g10/import.c:517
#, c-format
msgid "key %08lX: no user id\n"
-msgstr "clé %08lX: pas de nom d'utilisateur\n"
+msgstr "clé %08lX : pas de nom d'utilisateur\n"
#: g10/import.c:336
#, c-format
msgid "key %08lX: no valid user ids\n"
-msgstr "clé %08lX: pas de nom d'utilisateur valide\n"
+msgstr "clé %08lX : pas de nom d'utilisateur valide\n"
#: g10/import.c:338
msgid "this may be caused by a missing self-signature\n"
msgstr "cela peut provenir d'une auto-signature manquante\n"
#: g10/import.c:349 g10/import.c:585
#, c-format
msgid "key %08lX: public key not found: %s\n"
-msgstr "clé %08lX: clé publique pas trouvée: %s\n"
+msgstr "clé %08lX : clé publique pas trouvée: %s\n"
#: g10/import.c:355
msgid "no default public keyring\n"
msgstr "pas de porte-clés public par défaut\n"
#: g10/import.c:359 g10/openfile.c:105 g10/sign.c:205 g10/sign.c:569
#, c-format
msgid "writing to '%s'\n"
msgstr "écriture de '%s'\n"
#: g10/import.c:363 g10/import.c:423 g10/import.c:639
#, c-format
msgid "can't lock public keyring: %s\n"
-msgstr "ne peut verrouiller le porte-clés public: %s\n"
+msgstr "ne peut verrouiller le porte-clés public : %s\n"
#: g10/import.c:366
#, c-format
msgid "can't write to keyring: %s\n"
-msgstr "ne peut écrire sur le porte-clés: %s\n"
+msgstr "ne peut écrire le porte-clés : %s\n"
#: g10/import.c:370
#, c-format
msgid "key %08lX: public key imported\n"
-msgstr "clé %08lX: clé publique importée\n"
+msgstr "clé %08lX : clé publique importée\n"
#: g10/import.c:383
#, c-format
msgid "key %08lX: doesn't match our copy\n"
-msgstr "clé %08lX: ne vérifie pas notre copie\n"
+msgstr "clé %08lX : ne ressemble pas à notre copie\n"
#: g10/import.c:396 g10/import.c:594
#, c-format
msgid "key %08lX: can't locate original keyblock: %s\n"
-msgstr "clé %08lX: ne peut trouver le bloc de clés original: %s\n"
+msgstr "clé %08lX : ne peut trouver le bloc de clés original : %s\n"
#: g10/import.c:403 g10/import.c:601
#, c-format
msgid "key %08lX: can't read original keyblock: %s\n"
-msgstr "clé %08lX: ne peut lire le bloc de clés original: %s\n"
+msgstr "clé %08lX : ne peut lire le bloc de clés original : %s\n"
#: g10/import.c:420 g10/import.c:532 g10/import.c:636
msgid "writing keyblock\n"
msgstr "écriture du bloc de clés\n"
#: g10/import.c:426 g10/import.c:642
#, c-format
msgid "can't write keyblock: %s\n"
-msgstr "ne peut écrire le bloc de clés: %s\n"
+msgstr "ne peut écrire le bloc de clés : %s\n"
#: g10/import.c:431
#, c-format
msgid "key %08lX: 1 new user-id\n"
-msgstr "clé %08lX: un nouvel utilisateur\n"
+msgstr "clé %08lX : un nouvel utilisateur\n"
#: g10/import.c:434
#, c-format
msgid "key %08lX: %d new user-ids\n"
-msgstr "clé %08lX: %d nouveaux utilisateurs\n"
+msgstr "clé %08lX : %d nouveaux utilisateurs\n"
#: g10/import.c:437
#, c-format
msgid "key %08lX: 1 new signature\n"
-msgstr "clé %08lX: une nouvelle signature\n"
+msgstr "clé %08lX : une nouvelle signature\n"
#: g10/import.c:440
#, c-format
msgid "key %08lX: %d new signatures\n"
-msgstr "clé %08lX: %d nouvelles signatures\n"
+msgstr "clé %08lX : %d nouvelles signatures\n"
#: g10/import.c:443
#, c-format
msgid "key %08lX: 1 new subkey\n"
-msgstr "clé %08lX: une nouvelle sous-clé\n"
+msgstr "clé %08lX : une nouvelle sous-clé\n"
#: g10/import.c:446
#, c-format
msgid "key %08lX: %d new subkeys\n"
-msgstr "clé %08lX: %d nouvelles sous-clés\n"
+msgstr "clé %08lX : %d nouvelles sous-clés\n"
#: g10/import.c:456
#, c-format
msgid "key %08lX: not changed\n"
-msgstr "clé %08lX: n'a pas changé\n"
+msgstr "clé %08lX : n'a pas changé\n"
#: g10/import.c:535
#, c-format
msgid "can't lock secret keyring: %s\n"
-msgstr "ne peut verrouiller le porte-clés secret: %s\n"
+msgstr "ne peut verrouiller le porte-clés secret : %s\n"
#: g10/import.c:538
#, c-format
msgid "can't write keyring: %s\n"
-msgstr "ne peut écrire le porte-clés: %s\n"
+msgstr "ne peut écrire le porte-clés : %s\n"
#. we are ready
#: g10/import.c:541
#, c-format
msgid "key %08lX: secret key imported\n"
-msgstr "clé %08lX: clé secrète importée\n"
+msgstr "clé %08lX : clé secrète importée\n"
#. we can't merge secret keys
#: g10/import.c:545
#, c-format
msgid "key %08lX: already in secret keyring\n"
-msgstr "clé %08lX: déjà dans le porte-clés secret\n"
+msgstr "clé %08lX : déjà dans le porte-clés secret\n"
#: g10/import.c:550
#, c-format
msgid "key %08lX: secret key not found: %s\n"
-msgstr "clé %08lX: clé secrète pas trouvée: %s\n"
+msgstr "clé %08lX : clé secrète pas trouvée: %s\n"
#: g10/import.c:579
#, c-format
msgid "key %08lX: no public key - can't apply revocation certificate\n"
msgstr ""
-"clé %08lX: pas de clé publique - ne peut appliquer le certificat de\n"
+"clé %08lX : pas de clé publique - ne peut appliquer le certificat de\n"
"révocation\n"
#: g10/import.c:612
#, c-format
msgid "key %08lX: invalid revocation certificate: %s - rejected\n"
-msgstr "clé %08lX: certificat de révocation invalide: %s - rejeté\n"
+msgstr "clé %08lX : certificat de révocation invalide : %s - rejeté\n"
#: g10/import.c:646
#, c-format
msgid "key %08lX: revocation certificate imported\n"
-msgstr "clé %08lX: certificat de révocation importé\n"
+msgstr "clé %08lX : certificat de révocation importé\n"
#: g10/import.c:677
#, c-format
msgid "key %08lX: no user-id for signature\n"
-msgstr "clé %08lX: pas d'utilisateur pour la signature\n"
+msgstr "clé %08lX : pas d'utilisateur pour la signature\n"
#: g10/import.c:684
#, c-format
msgid "key %08lX: unsupported public key algorithm\n"
-msgstr "clé %08lX: algorithme de clé publique non supporté\n"
+msgstr "clé %08lX : algorithme de clé publique non supporté\n"
#: g10/import.c:685
#, c-format
msgid "key %08lX: invalid self-signature\n"
-msgstr "clé %08lX: auto-signature invalide\n"
+msgstr "clé %08lX : auto-signature invalide\n"
#: g10/import.c:714
#, c-format
msgid "key %08lX: skipped userid '"
-msgstr "clé %08lX: utilisateur non pris en compte '"
+msgstr "clé %08lX : utilisateur non pris en compte '"
#: g10/import.c:737
#, c-format
msgid "key %08lX: revocation certificate at wrong place - skipped\n"
-msgstr ""
-"clé %08lX: certificat de révocation au mauvais endroit - non prise en "
-"compte\n"
+msgstr "clé %08lX : certificat de révocation au mauvais endroit - ignorée\n"
#: g10/import.c:745
#, c-format
msgid "key %08lX: invalid revocation certificate: %s - skipped\n"
-msgstr ""
-"clé %08lX: certificat de révocation invalide: %s - non prise en compte\n"
+msgstr "clé %08lX : certificat de révocation invalide : %s - ignorée\n"
#: g10/import.c:804
#, c-format
msgid "key %08lX: revocation certificate added\n"
-msgstr "clé %08lX: certificat de révocation ajouté\n"
+msgstr "clé %08lX : certificat de révocation ajouté\n"
#: g10/import.c:918 g10/import.c:973
#, c-format
msgid "key %08lX: our copy has no self-signature\n"
-msgstr "clé %08lX: notre copie n'a pas d'auto-signature\n"
+msgstr "clé %08lX : notre copie n'a pas d'auto-signature\n"
#: g10/keyedit.c:81
#, c-format
msgid "%s: user not found\n"
-msgstr "%s: utilisateur non trouvé\n"
+msgstr "%s : utilisateur non trouvé\n"
#: g10/keyedit.c:164
msgid "[self-signature]"
msgstr "[auto-signature]"
#: g10/keyedit.c:182
msgid "1 bad signature\n"
msgstr "une mauvaise signature\n"
#: g10/keyedit.c:184
#, c-format
msgid "%d bad signatures\n"
msgstr "%d mauvaises signatures\n"
#: g10/keyedit.c:186
msgid "1 signature not checked due to a missing key\n"
msgstr "une signature non vérifiée à cause d'une clé manquante\n"
#: g10/keyedit.c:188
#, c-format
msgid "%d signatures not checked due to missing keys\n"
msgstr "%d signatures non vérifiées à cause de clés manquantes\n"
#: g10/keyedit.c:190
msgid "1 signature not checked due to an error\n"
msgstr "une signature non vérifiée à cause d'une erreur\n"
#: g10/keyedit.c:192
#, c-format
msgid "%d signatures not checked due to errors\n"
msgstr "%d signatures non vérifiées à cause d'erreurs\n"
#: g10/keyedit.c:194
msgid "1 user id without valid self-signature detected\n"
msgstr "un nom d'utilisateur sans auto-signature valide détecté\n"
#: g10/keyedit.c:196
#, c-format
msgid "%d user ids without valid self-signatures detected\n"
msgstr "%d nom d'utilisateurs sans auto-signature valide détecté\n"
#: g10/keyedit.c:258
#, c-format
msgid "Already signed by key %08lX\n"
msgstr "Déjà signé par la clé %08lX\n"
#: g10/keyedit.c:266
#, c-format
msgid "Nothing to sign with key %08lX\n"
msgstr "Rien à signer avec la clé %08lX\n"
#: g10/keyedit.c:275
msgid ""
"Are you really sure that you want to sign this key\n"
"with your key: \""
msgstr ""
"Etes-vous vraiment sûr(e) que vous voulez signer cette clé\n"
-"avec votre clé: \""
+"avec la vôtre : \""
#: g10/keyedit.c:282
msgid "Really sign? "
-msgstr "Signer réellement? "
+msgstr "Signer réellement ? "
#: g10/keyedit.c:303 g10/sign.c:65
#, c-format
msgid "signing failed: %s\n"
-msgstr "la signature a échoué: %s\n"
+msgstr "la signature a échoué : %s\n"
#: g10/keyedit.c:356
msgid "This key is not protected.\n"
msgstr "Cette clé n'est pas protégée.\n"
#: g10/keyedit.c:359
msgid "Key is protected.\n"
msgstr "La clé est protégée.\n"
#: g10/keyedit.c:376
#, c-format
msgid "Can't edit this key: %s\n"
-msgstr "Ne peut éditer cette clé: %s\n"
+msgstr "Ne peut éditer cette clé : %s\n"
#: g10/keyedit.c:381
msgid ""
"Enter the new passphrase for this secret key.\n"
"\n"
msgstr "Entrez le nouveau mot de passe pour cette clé secrète.\n"
#: g10/keyedit.c:393
msgid ""
"You don't want a passphrase - this is probably a *bad* idea!\n"
"\n"
msgstr ""
-"Vous ne voulez pas de mot de passe - cela est certainement une *mauvaise* "
-"idée\n"
+"Vous ne voulez pas de mot de passe - cela est certainement une\n"
+"*mauvaise* idée\n"
+"\n"
#: g10/keyedit.c:396
msgid "Do you really want to do this? "
msgstr "Voulez-vous vraiment faire cela? "
#: g10/keyedit.c:455
msgid "moving a key signature to the correct place\n"
-msgstr ""
+msgstr "replacer la signature d'une clé à l'endroit correct\n"
#: g10/keyedit.c:490
msgid "quit"
msgstr "quitter"
#: g10/keyedit.c:490
msgid "quit this menu"
msgstr "quitter ce menu"
#: g10/keyedit.c:491
msgid "q"
msgstr "q"
#: g10/keyedit.c:492
msgid "save"
msgstr "enregistrer"
#: g10/keyedit.c:492
msgid "save and quit"
msgstr "enregistrer et quitter"
+# FIXMOI : si je mets aide ça va demander de taper "aide"...
#: g10/keyedit.c:493
msgid "help"
-msgstr "aide"
+msgstr "help"
#: g10/keyedit.c:493
msgid "show this help"
-msgstr "montrer cette aide"
+msgstr "afficher cette aide"
# g10/keyedit.c:556 ???
#: g10/keyedit.c:495
msgid "fpr"
msgstr "fpr"
#: g10/keyedit.c:495
msgid "show fingerprint"
-msgstr "montrer l'empreinte"
+msgstr "afficher l'empreinte"
#: g10/keyedit.c:496
msgid "list"
msgstr "lister"
#: g10/keyedit.c:496
msgid "list key and user ids"
msgstr "lister la clé et les noms d'utilisateurs"
#: g10/keyedit.c:497
msgid "l"
msgstr "l"
#: g10/keyedit.c:498
msgid "uid"
msgstr "uid"
#: g10/keyedit.c:498
msgid "select user id N"
msgstr "sélectionner le nom d'utilisateur N"
#: g10/keyedit.c:499
msgid "key"
msgstr "clé"
#: g10/keyedit.c:499
msgid "select secondary key N"
msgstr "sélectionner la clé secondaire N"
#: g10/keyedit.c:500
msgid "check"
msgstr "vérifier"
#: g10/keyedit.c:500
msgid "list signatures"
msgstr "lister les signatures"
#: g10/keyedit.c:501
msgid "c"
msgstr "c"
#: g10/keyedit.c:502
msgid "sign"
msgstr "signer"
#: g10/keyedit.c:502
msgid "sign the key"
msgstr "signer la clé"
#: g10/keyedit.c:503
msgid "s"
msgstr "s"
#: g10/keyedit.c:504
msgid "debug"
msgstr "déboguer"
#: g10/keyedit.c:505
msgid "adduid"
msgstr "aj.ut"
#: g10/keyedit.c:505
msgid "add a user id"
msgstr "ajouter un utilisateur"
#: g10/keyedit.c:506
msgid "deluid"
msgstr "suppr.ut"
#: g10/keyedit.c:506
msgid "delete user id"
msgstr "enlever un utilisateur"
#: g10/keyedit.c:507
msgid "addkey"
msgstr "aj.clé"
#: g10/keyedit.c:507
msgid "add a secondary key"
msgstr "ajouter une clé secondaire"
#: g10/keyedit.c:508
msgid "delkey"
msgstr "suppr.clé"
#: g10/keyedit.c:508
msgid "delete a secondary key"
msgstr "enlever une clé secondaire"
#: g10/keyedit.c:509
msgid "expire"
msgstr "expire"
#: g10/keyedit.c:509
msgid "change the expire date"
msgstr "changer la date d'expiration"
#: g10/keyedit.c:510
msgid "toggle"
msgstr "changer"
#: g10/keyedit.c:510
msgid "toggle between secret and public key listing"
msgstr "passer de la liste des clés secrètes aux clés privées et inversement"
#: g10/keyedit.c:512
msgid "t"
msgstr "t"
#: g10/keyedit.c:513
msgid "pref"
msgstr "préf"
#: g10/keyedit.c:513
msgid "list preferences"
msgstr "lister les préférences"
#: g10/keyedit.c:514
msgid "passwd"
msgstr "mot.pas"
#: g10/keyedit.c:514
msgid "change the passphrase"
msgstr "changer le mot de passe"
#: g10/keyedit.c:515
msgid "trust"
msgstr "confi."
#: g10/keyedit.c:515
msgid "change the ownertrust"
msgstr "changer la confiance"
#: g10/keyedit.c:534
msgid "can't do that in batchmode\n"
msgstr "ne peut faire cela en mode automatique\n"
#. check that they match
#. FIXME: check that they both match
#: g10/keyedit.c:561
msgid "Secret key is available.\n"
msgstr "La clé secrète est disponible.\n"
#: g10/keyedit.c:590
msgid "Command> "
msgstr "Commande> "
#: g10/keyedit.c:617
msgid "Need the secret key to do this.\n"
msgstr "Il faut la clé secrète pour faire cela.\n"
#: g10/keyedit.c:639
msgid "Save changes? "
msgstr "Enregistrer les changements? "
#: g10/keyedit.c:642
msgid "Quit without saving? "
msgstr "Quitter sans enregistrer? "
#: g10/keyedit.c:652
#, c-format
msgid "update failed: %s\n"
-msgstr "la mise à jour a échoué: %s\n"
+msgstr "la mise à jour a échoué : %s\n"
#: g10/keyedit.c:659
#, c-format
msgid "update secret failed: %s\n"
-msgstr "la mise à jour de la clé secrète a échoué: %s\n"
+msgstr "la mise à jour de la clé secrète a échoué : %s\n"
#: g10/keyedit.c:666
msgid "Key not changed so no update needed.\n"
msgstr "La clé n'a pas changé donc la mise à jour est inutile.\n"
#: g10/keyedit.c:669 g10/keyedit.c:727
#, c-format
msgid "update of trust db failed: %s\n"
-msgstr "la mise à jour de la base de confiance a échoué: %s\n"
+msgstr "la mise à jour de la base de confiance a échoué : %s\n"
#: g10/keyedit.c:701
msgid "Really sign all user ids? "
-msgstr "Signer vraiment tous les utilisateurs? "
+msgstr "Signer vraiment tous les utilisateurs ? "
#: g10/keyedit.c:702
msgid "Hint: Select the user ids to sign\n"
-msgstr "Aide: Sélectionner les utilisateurs à signer\n"
+msgstr "Aide : Sélectionner les utilisateurs à signer\n"
#: g10/keyedit.c:738
msgid "You must select at least one user id.\n"
msgstr "Vous devez sélectionner au moins un utilisateur.\n"
#: g10/keyedit.c:740
msgid "You can't delete the last user id!\n"
-msgstr "Vous ne pouvez pas supprimer le dernier utilisateur!\n"
+msgstr "Vous ne pouvez pas supprimer le dernier utilisateur !\n"
#: g10/keyedit.c:743
msgid "Really remove all selected user ids? "
-msgstr "Enlever réellement tous les utilisateurs sélectionnés? "
+msgstr "Enlever réellement tous les utilisateurs sélectionnés ? "
#: g10/keyedit.c:744
msgid "Really remove this user id? "
-msgstr "Enlever réellement cet utilisateur? "
+msgstr "Enlever réellement cet utilisateur ? "
#: g10/keyedit.c:767
msgid "You must select at least one key.\n"
msgstr "Vous devez sélectionner au moins une clé.\n"
#: g10/keyedit.c:771
msgid "Do you really want to delete the selected keys? "
-msgstr "Voulez-vous supprimer les clés sélectionnées? "
+msgstr "Voulez-vous vraiment supprimer les clés sélectionnées ? "
#: g10/keyedit.c:772
msgid "Do you really want to delete this key? "
-msgstr "Voulez-vous vraiment supprimer cette clé? "
+msgstr "Voulez-vous vraiment supprimer cette clé ? "
#: g10/keyedit.c:819
msgid "Invalid command (try \"help\")\n"
-msgstr "Commande invalide (essayez \"help\")\n"
+msgstr "Commande invalide (essayez « help »)\n"
#: g10/keyedit.c:1197
msgid "Please remove selections from the secret keys.\n"
msgstr "Enlevez les sélections des clés secrètes.\n"
#: g10/keyedit.c:1203
msgid "Please select at most one secondary key.\n"
msgstr "Vous devez sélectionner au plus une clé secondaire.\n"
#: g10/keyedit.c:1207
msgid "Changing exiration time for a secondary key.\n"
msgstr "Changer la date d'expiration d'une clé secondaire.\n"
#: g10/keyedit.c:1209
msgid "Changing exiration time for the primary key.\n"
-msgstr "Changer la date d'expiration de la clé primaire.\n"
+msgstr "Changer la date d'expiration de la clé principale.\n"
#: g10/keyedit.c:1250
msgid "You can't change the expiration date of a v3 key\n"
-msgstr ""
+msgstr "Vous ne pouvez pas changer la date d'expiration d'une clé v3\n"
#: g10/keyedit.c:1266
msgid "No corresponding signature in secret ring\n"
msgstr "Pas de signature correspondante dans le porte-clés secret\n"
#: g10/keyedit.c:1326
#, c-format
msgid "No user id with index %d\n"
msgstr "Pas d'utilisateur avec l'index %d\n"
#: g10/keyedit.c:1371
#, c-format
msgid "No secondary key with index %d\n"
msgstr "Pas de clé secondaire avec l'index %d\n"
#: g10/mainproc.c:198
-#, fuzzy
msgid "public key encrypted data: Good DEK\n"
-msgstr "le décryptage de la clé publique a échoué: %s\n"
+msgstr "données chiffrées avec la clé publique : bonne clé de chiffrement\n"
#: g10/mainproc.c:201
#, c-format
msgid "public key decryption failed: %s\n"
-msgstr "le décryptage de la clé publique a échoué: %s\n"
+msgstr "le déchiffrement de la clé publique a échoué : %s\n"
#: g10/mainproc.c:228
-#, fuzzy
msgid "decryption okay\n"
-msgstr "le décryptage a échoué: %s\n"
+msgstr "le déchiffrement a réussi\n"
#: g10/mainproc.c:231
#, c-format
msgid "decryption failed: %s\n"
-msgstr "le décryptage a échoué: %s\n"
+msgstr "le déchiffrement a échoué : %s\n"
#: g10/mainproc.c:248
-#, fuzzy
msgid "NOTE: sender requested \"for-your-eyes-only\"\n"
-msgstr "note: l'expéditeur a demandé \"pour vos yeux seulement\"\n"
+msgstr "NOTE : l'expéditeur a demandé « pour vos yeux seulement »\n"
#: g10/mainproc.c:250
#, c-format
msgid "original file name='%.*s'\n"
-msgstr ""
+msgstr "nom de fichier original : '%.*s'\n"
#: g10/mainproc.c:833
msgid "signature verification suppressed\n"
-msgstr ""
+msgstr "vérification de signature supprimée\n"
#: g10/mainproc.c:839
#, c-format
msgid "Signature made %.*s using %s key ID %08lX\n"
-msgstr "Signature faite %.*s avec %s clé ID %08lX\n"
+msgstr "Signature faite %.*s avec une clé %s ID %08lX\n"
#: g10/mainproc.c:847
msgid "BAD signature from \""
msgstr "MAUVAISE signature de \""
#: g10/mainproc.c:848
msgid "Good signature from \""
msgstr "Bonne signature de \""
#: g10/mainproc.c:861
#, c-format
msgid "Can't check signature: %s\n"
-msgstr "Ne peut vérifier la signature: %s\n"
+msgstr "Ne peut vérifier la signature : %s\n"
#: g10/mainproc.c:934
msgid "old style (PGP 2.x) signature\n"
-msgstr ""
+msgstr "signature d'un ancien style (PGP 2.x)\n"
#: g10/mainproc.c:939
msgid "invalid root packet detected in proc_tree()\n"
-msgstr ""
+msgstr "paquet racine invalide détecté dans proc_tree()\n"
#: g10/misc.c:88
-#, fuzzy, c-format
+#, c-format
msgid "can't disable core dumps: %s\n"
-msgstr "ne peut ouvrir %s: %s\n"
+msgstr "ne peut empêcher la génération de fichiers core : %s\n"
#: g10/misc.c:90
msgid "WARNING: Program may create a core file!\n"
-msgstr ""
+msgstr "ATTENTION : Le programme peut créer un fichier core !\n"
#: g10/misc.c:198
msgid "Experimental algorithms should not be used!\n"
-msgstr ""
+msgstr "Les algorithmes expérimentaux ne devraient pas être utilisés !\n"
#: g10/misc.c:212
msgid ""
"RSA keys are deprecated; please consider creating a new key and use this key "
"in the future\n"
msgstr ""
-"Les clés RSA sont déconseillées: considérez créer une nouvelle clé et "
-"l'utiliser dans l'avenir\n"
+"Les clés RSA sont déconseillées : considérez créer une nouvelle clé\n"
+"et l'utiliser dans l'avenir\n"
#: g10/misc.c:233
msgid "This cipher algorithm is depreciated; please use a more standard one!\n"
msgstr ""
+"Cet algorithme de chiffrement est déconseillé ; utilisez-en un\n"
+"plus standard!\n"
#: g10/parse-packet.c:109
-#, fuzzy, c-format
+#, c-format
msgid "can't handle public key algorithm %d\n"
-msgstr "ne peut verrouiller le porte-clés public: %s\n"
+msgstr "ne peut gérer l'algorithme à clé publique %d\n"
+
+#: g10/parse-packet.c:801
+#, c-format
+msgid "subpacket of type %d has critical bit set\n"
+msgstr "un sous-paquet de type %d possède un bit critique\n"
#: g10/passphrase.c:141
msgid ""
"\n"
"You need a passphrase to unlock the secret key for\n"
"user: \""
msgstr ""
"\n"
"Vous avez besoin d'un mot de passe pour déverrouiller la clé secrète pour\n"
"l'utilisateur: \""
#: g10/passphrase.c:150
#, c-format
msgid "(%u-bit %s key, ID %08lX, created %s)\n"
msgstr "(clé de %u bits %s, ID %08lX, créée le %s)\n"
#: g10/passphrase.c:174
-#, fuzzy
msgid "Enter passphrase: "
-msgstr "Entrez le mot de passe: "
+msgstr "Entrez le mot de passe : "
#: g10/passphrase.c:178
-#, fuzzy
msgid "Repeat passphrase: "
-msgstr "Répétez le mot de passe: "
+msgstr "Répétez le mot de passe : "
#: g10/plaintext.c:102
msgid "data not saved; use option \"--output\" to save it\n"
msgstr ""
-"données non enregistrées; utilisez l'option \"--output\" pour\n"
+"données non enregistrées ; utilisez l'option \"--output\" pour\n"
"les enregistrer\n"
#: g10/plaintext.c:215
msgid "Please enter name of data file: "
-msgstr "Entrez le nom d'un fichier de données: "
+msgstr "Entrez le nom d'un fichier de données : "
#: g10/plaintext.c:236
msgid "reading stdin ...\n"
-msgstr ""
+msgstr "lecture de l'entrée standard...\n"
#: g10/plaintext.c:299
#, c-format
msgid "can't open signed data '%s'\n"
msgstr "ne peut ouvir les données signées '%s'\n"
#: g10/pubkey-enc.c:78
#, c-format
msgid "anonymous receiver; trying secret key %08lX ...\n"
-msgstr "destinataire anonyme; essai de la clé secrète %08lX ...\n"
+msgstr "destinataire anonyme ; essai de la clé secrète %08lX ...\n"
#: g10/pubkey-enc.c:84
msgid "okay, we are the anonymous receiver.\n"
msgstr "d'accord, nous sommes le destinataire anonyme.\n"
#: g10/pubkey-enc.c:136
-#, fuzzy
msgid "old encoding of the DEK is not supported\n"
-msgstr "l'algorithme de protection %d n'est pas supporté\n"
+msgstr "l'ancien codage de la clé de chiffrement (DEK) n'est pas supporté\n"
#: g10/pubkey-enc.c:183
-#, fuzzy, c-format
+#, c-format
msgid "NOTE: cipher algorithm %d not found in preferences\n"
msgstr ""
-"note: l'algorithme de cryptage %d n'a pas été trouvé dans les préférences\n"
+"NOTE : l'algorithme de chiffrement %d n'a pas été trouvé dans les "
+"préférences\n"
#: g10/seckey-cert.c:56
#, c-format
msgid "protection algorithm %d is not supported\n"
msgstr "l'algorithme de protection %d n'est pas supporté\n"
#: g10/seckey-cert.c:169
msgid "Invalid passphrase; please try again ...\n"
-msgstr "Mot de passe invalide; réessayez...\n"
+msgstr "Mot de passe invalide ; réessayez...\n"
#: g10/seckey-cert.c:216
-#, fuzzy
msgid "WARNING: Weak key detected - please change passphrase again.\n"
-msgstr "Attention: Mauvaise clé détectée - changez encore le mot de passe.\n"
+msgstr "ATTENTION : Mauvaise clé détectée - changez encore le mot de passe.\n"
#: g10/sig-check.c:155
msgid ""
"this is a PGP generated ElGamal key which is NOT secure for signatures!\n"
msgstr ""
-"Cela est une clé ElGamal générée par PGP qui n'est PAS sûre pour les\n"
+"Ceci est une clé ElGamal générée par PGP qui n'est PAS sûre pour les\n"
"signatures!\n"
#: g10/sig-check.c:165
msgid "public key created in future (time warp or clock problem)\n"
msgstr ""
"clé publique créée dans le futur (voyage dans le temps ou problème\n"
"d'horloge)\n"
#: g10/sig-check.c:170
-#, fuzzy, c-format
+#, c-format
msgid "NOTE: signature key expired %s\n"
-msgstr "attention: la clé de signature a expiré le %s\n"
+msgstr "NOTE : la clé de signature a expiré le %s\n"
+
+#: g10/sig-check.c:226
+msgid "assuming bad signature due to an unknown critical bit\n"
+msgstr ""
+"la signature est supposée être fausse car un bit critique est\n"
+"inconnu\n"
#: g10/sign.c:69
-#, fuzzy, c-format
+#, c-format
msgid "%s signature from: %s\n"
-msgstr "MAUVAISE signature de \""
+msgstr "Signature %s de : %s\n"
#: g10/sign.c:200 g10/sign.c:564
-#, fuzzy, c-format
+#, c-format
msgid "can't create %s: %s\n"
-msgstr "%s: ne peut créer: %s\n"
+msgstr "ne peut créer %s : %s\n"
#: g10/sign.c:296
-#, fuzzy
msgid "signing:"
-msgstr "signer"
+msgstr "signature :"
#: g10/sign.c:336
-#, fuzzy, c-format
+#, c-format
msgid "WARNING: '%s' is an empty file\n"
-msgstr "%s: attention: fichier vide\n"
+msgstr "ATTENTION : '%s' est un fichier vide\n"
#: g10/tdbio.c:116 g10/tdbio.c:1413
-#, fuzzy, c-format
+#, c-format
msgid "trustdb rec %lu: lseek failed: %s\n"
-msgstr "la mise à jour de la clé secrète a échoué: %s\n"
+msgstr "enregistrement de base de confiance %lu : lseek a échoué : %s\n"
#: g10/tdbio.c:122 g10/tdbio.c:1420
#, c-format
msgid "trustdb rec %lu: write failed (n=%d): %s\n"
msgstr ""
+"enregistrement de la base de confiance %lu : l'écriture a échoué (n=%d) : "
+"%s\n"
#: g10/tdbio.c:232
msgid "trustdb transaction to large\n"
-msgstr ""
+msgstr "transaction de base de confiance trop volumineuse\n"
#: g10/tdbio.c:402
-#, fuzzy, c-format
+#, c-format
msgid "%s: can't access: %s\n"
-msgstr "%s: ne peut créer: %s\n"
+msgstr "%s : ne peut accéder : %s\n"
#: g10/ringedit.c:273 g10/tdbio.c:422
-#, fuzzy, c-format
+#, c-format
msgid "%s: can't create directory: %s\n"
-msgstr "%s: ne peut créer: %s\n"
+msgstr "%s : ne peut créer le répertoire : %s\n"
#: g10/ringedit.c:279 g10/tdbio.c:425
-#, fuzzy, c-format
+#, c-format
msgid "%s: directory created\n"
-msgstr "%s: ne peut créer: %s\n"
+msgstr "%s : répertoire créé\n"
#: g10/tdbio.c:429
#, c-format
msgid "%s: directory does not exist!\n"
-msgstr ""
+msgstr "%s : le répertoire n'existe pas !\n"
#: g10/openfile.c:101 g10/openfile.c:165 g10/ringedit.c:1256 g10/tdbio.c:435
#, c-format
msgid "%s: can't create: %s\n"
-msgstr "%s: ne peut créer: %s\n"
+msgstr "%s : ne peut créer : %s\n"
#: g10/tdbio.c:459
#, c-format
msgid "%s: failed to create version record: %s"
-msgstr ""
+msgstr "%s : n'a pas pu créer un enregistrement de version : %s"
#: g10/tdbio.c:463
#, c-format
msgid "%s: invalid trust-db created\n"
-msgstr ""
+msgstr "%s : base de confiance invalide créée\n"
#: g10/tdbio.c:465
-#, fuzzy, c-format
+#, c-format
msgid "%s: trust-db created\n"
-msgstr "%s: ne peut créer: %s\n"
+msgstr "%s : base de confiance créée\n"
#: g10/tdbio.c:506
#, c-format
msgid "%s: invalid trust-db\n"
-msgstr ""
+msgstr "%s : base de confiance invalide\n"
#: g10/tdbio.c:540
-#, fuzzy, c-format
+#, c-format
msgid "%s: failed to create hashtable: %s\n"
-msgstr "%s: ne peut créer: %s\n"
+msgstr "%s : la création de la table de hachage a échoué : %s\n"
#: g10/tdbio.c:548
-#, fuzzy, c-format
+#, c-format
msgid "%s: error updating version record: %s\n"
-msgstr "%s: erreur pendant la vérification de la clé: %s\n"
+msgstr ""
+"%s : erreur pendant la mise à jour de l'enregistrement de version : %s\n"
#: g10/tdbio.c:564 g10/tdbio.c:603 g10/tdbio.c:628 g10/tdbio.c:1346
#: g10/tdbio.c:1373
-#, fuzzy, c-format
+#, c-format
msgid "%s: error reading version record: %s\n"
-msgstr "%s: erreur pendant la vérification de la clé: %s\n"
+msgstr "%s : erreur pendant la lecture de l'enregistrement de version : %s\n"
#: g10/tdbio.c:577
-#, fuzzy, c-format
+#, c-format
msgid "%s: error writing version record: %s\n"
-msgstr "%s: erreur pendant la vérification de la clé: %s\n"
+msgstr "%s : erreur pendant l'écriture de l'enregistrement de version : %s\n"
#: g10/tdbio.c:1053
-#, fuzzy, c-format
+#, c-format
msgid "trustdb: lseek failed: %s\n"
-msgstr "la mise à jour de la clé secrète a échoué: %s\n"
+msgstr "base de confiance : « lseek() » a échoué : %s\n"
#: g10/tdbio.c:1061
-#, fuzzy, c-format
+#, c-format
msgid "trustdb: read failed (n=%d): %s\n"
-msgstr "la mise à jour de la base de confiance a échoué: %s\n"
+msgstr "base de confiance : la lecture a échoué (n=%d) : %s\n"
#: g10/tdbio.c:1082
-#, fuzzy, c-format
+#, c-format
msgid "%s: not a trustdb file\n"
-msgstr "la mise à jour de la base de confiance a échoué: %s\n"
+msgstr "%s : ce n'est pas un fichier de base de confiance\n"
#: g10/tdbio.c:1098
#, c-format
msgid "%s: version record with recnum %lu\n"
-msgstr ""
+msgstr "%s : enregistrement de version avec un numéro %lu\n"
#: g10/tdbio.c:1103
-#, fuzzy, c-format
+#, c-format
msgid "%s: invalid file version %d\n"
-msgstr "entête de signature claire invalide\n"
+msgstr "%s : version %d du fichier invalide\n"
#: g10/tdbio.c:1379
-#, fuzzy, c-format
+#, c-format
msgid "%s: error reading free record: %s\n"
-msgstr "%s: erreur pendant la vérification de la clé: %s\n"
+msgstr "%s : erreur pendant la lecture de l'enregistrement libre : %s\n"
#: g10/tdbio.c:1387
-#, fuzzy, c-format
+#, c-format
msgid "%s: error writing dir record: %s\n"
-msgstr "%s: erreur pendant la vérification de la clé: %s\n"
+msgstr ""
+"%s : erreur pendant l'écriture de l'enregistrement de\n"
+"répertoire : %s\n"
#: g10/tdbio.c:1397
#, c-format
msgid "%s: failed to zero a record: %s\n"
-msgstr ""
+msgstr "%s : n'a pu mettre un enregistrement à zéro : %s\n"
#: g10/tdbio.c:1427
#, c-format
msgid "%s: failed to append a record: %s\n"
-msgstr ""
+msgstr "%s : n'a pas pu ajouter un enregistrement : %s\n"
#: g10/trustdb.c:134
msgid "The trust DB is corrupted; please run \"gpgm --fix-trust-db\".\n"
msgstr ""
-"La base de confiance est corrompue; exécutez \"gpgm --fix-trust-db\".\n"
+"La base de confiance est corrompue ; exécutez « gpgm --fix-trust-db ».\n"
#: g10/trustdb.c:147
#, c-format
msgid "trust record %lu, req type %d: read failed: %s\n"
msgstr ""
+"enregistrement de confiance %lu, type de requête %d : la lecture a échoué : "
+"%s\n"
#: g10/trustdb.c:162
#, c-format
msgid "trust record %lu, type %d: write failed: %s\n"
-msgstr ""
+msgstr "enregistrement de confiance %lu, type %d : l'écriture a échoué : %s\n"
#: g10/trustdb.c:176
-#, fuzzy, c-format
+#, c-format
msgid "trust record %lu: delete failed: %s\n"
-msgstr "la mise à jour de la clé secrète a échoué: %s\n"
+msgstr "enregistrement de confiance %lu : la suppression a échoué : %s\n"
#: g10/trustdb.c:190
-#, fuzzy, c-format
+#, c-format
msgid "trust db: sync failed: %s\n"
-msgstr "la mise à jour de la base de confiance a échoué: %s\n"
+msgstr "base de confiance a échoué : la synchronisation a échoué : %s\n"
#: g10/trustdb.c:319
#, c-format
msgid "error reading dir record for LID %lu: %s\n"
msgstr ""
+"erreur pendant la lecture de l'enregistrement de répertoire pour\n"
+"le LID %lu : %s\n"
#: g10/trustdb.c:326
#, c-format
msgid "lid %lu: expected dir record, got type %d\n"
-msgstr ""
+msgstr "lid %lu : enregistrement de répertoire attendu, a reçu le type %d\n"
#: g10/trustdb.c:331
#, c-format
msgid "no primary key for LID %lu\n"
-msgstr ""
+msgstr "pas de clé principale pour le LID %lu\n"
#: g10/trustdb.c:336
-#, fuzzy, c-format
+#, c-format
msgid "error reading primary key for LID %lu: %s\n"
-msgstr "erreur pendant la création du mot de passe: %s\n"
+msgstr "erreur pendant la lecture de la clé principale pour le LID %lu : %s\n"
#: g10/trustdb.c:412
#, c-format
msgid "chained sigrec %lu has a wrong owner\n"
msgstr "l'enregistrement de signature %lu a un mauvais propriétaire\n"
#: g10/trustdb.c:455
-#, fuzzy, c-format
+#, c-format
msgid "'%s' is not a valid long keyID\n"
-msgstr "Caractère invalide dans le commentaire\n"
+msgstr "'%s' n'est pas une identification longue de clé valide\n"
#: g10/trustdb.c:490
-#, fuzzy, c-format
+#, c-format
msgid "key %08lX: no public key for trusted key - skipped\n"
-msgstr "clé %08lX: clé secrète sans clé publique - non prise en compte\n"
+msgstr "clé %08lX : pas de clé publique pour la clé certifiée - ignorée\n"
#: g10/trustdb.c:499 g10/trustdb.c:557
#, c-format
msgid "key %08lX: can't put it into the trustdb\n"
-msgstr "clé %08lX: ne peut mettre cela dans la base de confiance\n"
+msgstr "clé %08lX : ne peut être mise dans la base de confiance\n"
#: g10/trustdb.c:504 g10/trustdb.c:563
#, c-format
msgid "key %08lX: query record failed\n"
-msgstr "clé %08lX: l'enregistrement de requête a échoué\n"
+msgstr "clé %08lX : l'enregistrement de requête a échoué\n"
#: g10/trustdb.c:509 g10/trustdb.c:572
-#, fuzzy, c-format
+#, c-format
msgid "key %08lX: already in trusted key table\n"
-msgstr "clé %08lX: déjà dans la table des clés secrètes\n"
+msgstr "clé %08lX : déjà dans la table des clés certifiées\n"
#: g10/trustdb.c:512 g10/trustdb.c:575
-#, fuzzy, c-format
+#, c-format
msgid "key %08lX: accepted as trusted key.\n"
-msgstr "clé %08lX: acceptée comme clé secrète.\n"
+msgstr "clé %08lX : acceptée comme clé certifiée.\n"
#: g10/trustdb.c:528
-#, fuzzy, c-format
+#, c-format
msgid "NOTE: secret key %08lX is NOT protected.\n"
-msgstr "Cette clé n'est pas protégée.\n"
+msgstr "NOTE : la clé secrète %08lX n'est PAS protégée.\n"
#: g10/trustdb.c:540
#, c-format
msgid "key %08lX: secret key without public key - skipped\n"
-msgstr "clé %08lX: clé secrète sans clé publique - non prise en compte\n"
+msgstr "clé %08lX : clé secrète sans clé publique - non prise en compte\n"
#: g10/trustdb.c:547
#, c-format
msgid "key %08lX: secret and public key don't match\n"
-msgstr "clé %08lX: les clés secrète et publique ne correspondent pas\n"
+msgstr "clé %08lX : les clés secrète et publique ne correspondent pas\n"
#: g10/trustdb.c:583
-#, fuzzy, c-format
+#, c-format
msgid "enumerate secret keys failed: %s\n"
-msgstr "enum_secret_keys a échoué: %s\n"
+msgstr "l'énumération des clés secrètes a échoué : %s\n"
#: g10/trustdb.c:766
-#, fuzzy, c-format
+#, c-format
msgid "lid %lu: read dir record failed: %s\n"
-msgstr "clé %08lX: l'insertion d'enregistrement de confiance a échoué: %s\n"
+msgstr "lid %lu : la lecture d'enregistrement de répertoire a échoué : %s\n"
#: g10/trustdb.c:775
-#, fuzzy, c-format
+#, c-format
msgid "lid %lu: read key record failed: %s\n"
-msgstr "clé %08lX: l'insertion d'enregistrement de confiance a échoué: %s\n"
+msgstr "lid %lu : la lecture de l''enregistrement de clé a échoué : %s\n"
#: g10/trustdb.c:785
-#, fuzzy, c-format
+#, c-format
msgid "lid %lu: read uid record failed: %s\n"
-msgstr "clé %08lX: l'insertion d'enregistrement de confiance a échoué: %s\n"
+msgstr "lid %lu : la lecture d'enregistrement d'uid a échoué : %s\n"
#: g10/trustdb.c:794
-#, fuzzy, c-format
+#, c-format
msgid "lid %lu: read pref record failed: %s\n"
-msgstr "clé %08lX: l'insertion d'enregistrement de confiance a échoué: %s\n"
+msgstr "lid %lu : la lecture d'enregistrement de préférences a échoué : %s\n"
#: g10/trustdb.c:804
-#, fuzzy, c-format
+#, c-format
msgid "lid %lu: read sig record failed: %s\n"
-msgstr "clé %08lX: l'insertion d'enregistrement de confiance a échoué: %s\n"
+msgstr "lid %lu : la lecture d'enregistrement de signature a échoué : %s\n"
#: g10/trustdb.c:999
msgid "Ooops, no keys\n"
-msgstr ""
+msgstr "Ooops, pas de clé\n"
#: g10/trustdb.c:1003
-#, fuzzy
msgid "Ooops, no user ids\n"
-msgstr "lister la clé et les noms d'utilisateurs"
+msgstr "Ooops, pas de nom d'utilisateur\n"
#: g10/trustdb.c:1074 g10/trustdb.c:1092
#, c-format
msgid "user '%s' read problem: %s\n"
-msgstr ""
+msgstr "problème de lecture de l'utilisateur '%s' : %s\n"
#: g10/trustdb.c:1077 g10/trustdb.c:1095
#, c-format
msgid "user '%s' list problem: %s\n"
-msgstr ""
+msgstr "problème de liste à l'utilisateur '%s' : %s\n"
#: g10/trustdb.c:1085 g10/trustdb.c:1300
-#, fuzzy, c-format
+#, c-format
msgid "user '%s' not found: %s\n"
-msgstr "%s: utilisateur non trouvé\n"
+msgstr "l'utilisateur '%s' n'a pas été trouvé : %s\n"
#: g10/trustdb.c:1087 g10/trustdb.c:1302
#, c-format
msgid "problem finding '%s' in trustdb: %s\n"
-msgstr ""
+msgstr "problème de recherche de '%s' dans la base de confiance : %s\n"
#: g10/trustdb.c:1090
#, c-format
msgid "user '%s' not in trustdb\n"
-msgstr ""
+msgstr "l'utilisateur '%s' n'est pas dans la base de confiance\n"
#: g10/trustdb.c:1125
#, c-format
msgid ""
"# List of assigned trustvalues, created %s\n"
"# (Use \"gpgm --import-ownertrust\" to restore them)\n"
msgstr ""
+"# Liste des indices de confiance assignés, créée le %s\n"
+"# (Utiliser « gpgm --import-ownertrust » pour les restaurer)\n"
#: g10/trustdb.c:1131
msgid "directory record w/o primary key\n"
-msgstr ""
+msgstr "enregistrement de répertoire sans clé principale\n"
#: g10/trustdb.c:1138
-#, fuzzy, c-format
+#, c-format
msgid "error reading key record: %s\n"
-msgstr "%s: erreur pendant la vérification de la clé: %s\n"
+msgstr "erreur pendant la lecture de l'enregistrement de clé : %s\n"
#: g10/trustdb.c:1178
-msgid "line to long\n"
-msgstr ""
+msgid "line too long\n"
+msgstr "ligne trop longue\n"
#: g10/trustdb.c:1186
msgid "error: missing colon\n"
-msgstr ""
+msgstr "erreur : deux-points manquant\n"
#: g10/trustdb.c:1191
-#, fuzzy
msgid "error: invalid fingerprint\n"
-msgstr "erreur dans la ligne de remorque\n"
+msgstr "erreur : empreinte digitale invalide\n"
#: g10/trustdb.c:1195
-#, fuzzy
msgid "error: no ownertrust value\n"
-msgstr "exporter les valeurs de confiance"
+msgstr "erreur : pas d'indice de confiance\n"
#: g10/trustdb.c:1209
#, c-format
msgid "LID %lu: changing trust from %u to %u\n"
-msgstr ""
+msgstr "LID %lu : changement de la confiance de %u vers %u\n"
#: g10/trustdb.c:1212
#, c-format
msgid "LID %lu: setting trust to %u\n"
-msgstr ""
+msgstr "LID %lu : la confiance est maintenant %u\n"
#: g10/trustdb.c:1220
msgid "key not in trustdb, searching ring.\n"
-msgstr ""
+msgstr "la clé n'est pas dans la base de confiance, recherche du porte-clés.\n"
#: g10/trustdb.c:1223
-#, fuzzy, c-format
+#, c-format
msgid "key not in ring: %s\n"
-msgstr "ne peut écrire le porte-clés: %s\n"
+msgstr "clé absente du porte-clés : %s\n"
#: g10/trustdb.c:1227
msgid "Oops: key is now in trustdb???\n"
-msgstr ""
+msgstr "Oops : la clé est maintenant dans la base de confiance ???\n"
#. update the ownertrust
#: g10/trustdb.c:1232
-#, fuzzy, c-format
+#, c-format
msgid "insert trust record failed: %s\n"
-msgstr "clé %08lX: l'insertion d'enregistrement de confiance a échoué: %s\n"
+msgstr "l'insertion d'enregistrement de confiance a échoué : %s\n"
#. error
#: g10/trustdb.c:1238
-#, fuzzy, c-format
+#, c-format
msgid "error finding dir record: %s\n"
-msgstr "suppression d'armure non réussie: %s\n"
+msgstr "erreur pendant la recherche de l'enregistrement de répertoire : %s\n"
#: g10/trustdb.c:1305
#, c-format
msgid "user '%s' not in trustdb - inserting\n"
-msgstr ""
+msgstr "l'utilisateur '%s' n'est pas dans la base de confiance - insertion\n"
#: g10/trustdb.c:1308
-#, fuzzy, c-format
+#, c-format
msgid "failed to put '%s' into trustdb: %s\n"
-msgstr "n'a pas pu initialiser la base de confiance: %s\n"
+msgstr "n'a pas pu insérer '%s' dans la base de confiance : %s\n"
#: g10/trustdb.c:1355
#, c-format
msgid "%s: keyblock read problem: %s\n"
-msgstr ""
+msgstr "%s : problème de lecture du bloc de clés : %s\n"
#: g10/trustdb.c:1369
-#, fuzzy, c-format
+#, c-format
msgid "%s: update failed: %s\n"
-msgstr "la mise à jour a échoué: %s\n"
+msgstr "%s : la mise à jour a échoué : %s\n"
#: g10/trustdb.c:1372
-#, fuzzy, c-format
+#, c-format
msgid "%s: updated\n"
-msgstr "\t%lu clés mises à jour\n"
+msgstr "%s : mis à jour\n"
#: g10/trustdb.c:1374
#, c-format
msgid "%s: okay\n"
-msgstr ""
+msgstr "%s : OK\n"
#: g10/trustdb.c:1389
#, c-format
msgid "lid %lu: dir record w/o key - skipped\n"
-msgstr ""
+msgstr "lid %lu : enregistrement de répertoire sans clé - ignoré\n"
#: g10/trustdb.c:1402
-#, fuzzy, c-format
+#, c-format
msgid "lid %lu: keyblock not found: %s\n"
-msgstr "clé %08lX: clé publique pas trouvée: %s\n"
+msgstr "lid %lu : le bloc de clés n'a pas été trouvé : %s\n"
#: g10/trustdb.c:1411 g10/trustdb.c:1480
-#, fuzzy, c-format
+#, c-format
msgid "lid %lu: update failed: %s\n"
-msgstr "la mise à jour a échoué: %s\n"
+msgstr "lid %lu : la mise à jour a échoué: %s\n"
#: g10/trustdb.c:1417 g10/trustdb.c:1486
-#, fuzzy, c-format
+#, c-format
msgid "lid %lu: updated\n"
-msgstr "\t%lu clés mises à jour\n"
+msgstr "lid %lu : mis à jour\n"
#: g10/trustdb.c:1421 g10/trustdb.c:1490
-#, fuzzy, c-format
+#, c-format
msgid "lid %lu: okay\n"
-msgstr "lid %lu: pas de clé primaire\n"
+msgstr "lid %lu : OK\n"
#: g10/trustdb.c:1428 g10/trustdb.c:1496
#, c-format
msgid "%lu keys processed\n"
msgstr "%lu clés traitées\n"
#: g10/trustdb.c:1430
#, c-format
msgid "\t%lu keys skipped\n"
-msgstr "\t%lu clés non prises en compte\n"
+msgstr "\t%lu clés ignorées\n"
#: g10/trustdb.c:1432 g10/trustdb.c:1498
#, c-format
msgid "\t%lu keys with errors\n"
msgstr "\t%lu clés avec erreurs\n"
#: g10/trustdb.c:1434 g10/trustdb.c:1500
#, c-format
msgid "\t%lu keys updated\n"
msgstr "\t%lu clés mises à jour\n"
#: g10/trustdb.c:1464
-#, fuzzy, c-format
+#, c-format
msgid "lid ?: insert failed: %s\n"
-msgstr "la mise à jour de la clé secrète a échoué: %s\n"
+msgstr "lid ? : l'insertion a échoué : %s\n"
#: g10/trustdb.c:1469
-#, fuzzy, c-format
+#, c-format
msgid "lid %lu: insert failed: %s\n"
-msgstr "la mise à jour de la clé secrète a échoué: %s\n"
+msgstr "lid %lu : l'insertion a échoué : %s\n"
#: g10/trustdb.c:1475
-#, fuzzy, c-format
+#, c-format
msgid "lid %lu: inserted\n"
-msgstr "\t%lu clés insérées\n"
+msgstr "lid %lu : inséré\n"
#: g10/trustdb.c:1502
#, c-format
msgid "\t%lu keys inserted\n"
msgstr "\t%lu clés insérées\n"
#: g10/trustdb.c:1505
-#, fuzzy, c-format
+#, c-format
msgid "enumerate keyblocks failed: %s\n"
-msgstr "enum_secret_keys a échoué: %s\n"
+msgstr "l'énumération des blocs de clés a échoué : %s\n"
#: g10/trustdb.c:1550
-#, fuzzy, c-format
+#, c-format
msgid "check_trust: search dir record failed: %s\n"
-msgstr "clé %08lX: l'insertion d'enregistrement de confiance a échoué: %s\n"
+msgstr ""
+"check_trust : la recherche d'enregistrement de répertoire a échoué : %s\n"
#: g10/trustdb.c:1557
#, c-format
msgid "key %08lX: insert trust record failed: %s\n"
-msgstr "clé %08lX: l'insertion d'enregistrement de confiance a échoué: %s\n"
+msgstr "clé %08lX : l'insertion d'enregistrement de confiance a échoué : %s\n"
#: g10/trustdb.c:1561
#, c-format
msgid "key %08lX.%lu: inserted into trustdb\n"
-msgstr "clé %08lX.%lu: insérée dans la base de confiance\n"
+msgstr "clé %08lX.%lu : insérée dans la base de confiance\n"
#: g10/trustdb.c:1569
#, c-format
msgid "key %08lX.%lu: created in future (time warp or clock problem)\n"
-msgstr "clé %08lX.%lu: créée dans le futur (problème d'horloge)\n"
+msgstr ""
+"clé %08lX.%lu : créée dans le futur (voyage temporel ou\n"
+"problème d'horloge)\n"
#: g10/trustdb.c:1576
#, c-format
msgid "key %08lX.%lu: expired at %s\n"
-msgstr "clé %08lX.%lu: a expiré le %s\n"
+msgstr "clé %08lX.%lu : a expiré le %s\n"
#: g10/trustdb.c:1584
#, c-format
msgid "key %08lX.%lu: trust check failed: %s\n"
-msgstr "clé %08lX.%lu: la vérification de confiance a échoué: %s\n"
+msgstr "clé %08lX.%lu : la vérification de confiance a échoué: %s\n"
#: g10/trustdb.c:1753 g10/trustdb.c:1782 g10/trustdb.c:2521
msgid "WARNING: can't yet handle long pref records\n"
msgstr ""
+"ATTENTION : les enregistrements de préférences longs ne sont pas encore\n"
+"supportés\n"
#: g10/trustdb.c:1804
-#, fuzzy, c-format
+#, c-format
msgid "get_dir_record: search_record failed: %s\n"
-msgstr "la mise à jour de la clé secrète a échoué: %s\n"
+msgstr "get_dir_record : search_record a échoué : %s\n"
#: g10/trustdb.c:1867
-#, fuzzy, c-format
+#, c-format
msgid "NOTE: sig rec %lu[%d] in hintlist of %lu but marked as checked\n"
msgstr ""
-"note: enregistrement de signature %lu[%d] dans la liste d'aide de %lu mais\n"
-"mais marqué comme vérifié\n"
+"NOTE : l'enregistrement de signature %lu[%d] est dans la liste d'aide\n"
+"de %lu mais marqué comme vérifié\n"
#: g10/trustdb.c:1871
-#, fuzzy, c-format
+#, c-format
msgid "NOTE: sig rec %lu[%d] in hintlist of %lu but not marked\n"
msgstr ""
-"note: enregistrement de signature %lu[%d] dans la liste d'aide de %lu mais\n"
-"non marqué\n"
+"NOTE : l'enregistrement de signature %lu[%d] est dans la liste d'aide\n"
+"de %lu mais n'est pas marqué\n"
#. we need the dir record
#: g10/trustdb.c:1878
-#, fuzzy, c-format
+#, c-format
msgid "sig rec %lu[%d] in hintlist of %lu does not point to a dir record\n"
msgstr ""
-"l'enregistrement de signature %lu[%d] dans la liste d'aide de %u ne pointe\n"
-"pas vers un enregistrement de répertoire\n"
+"l'enregistrement de signature %lu[%d] dans la liste d'aide de %lu\n"
+"ne pointe pas vers un enregistrement de répertoire\n"
#: g10/trustdb.c:1884
#, c-format
msgid "lid %lu: no primary key\n"
-msgstr "lid %lu: pas de clé primaire\n"
+msgstr "lid %lu : pas de clé primaire\n"
#: g10/trustdb.c:1917
#, c-format
msgid "lid %lu: user id not found in keyblock\n"
-msgstr "lid %lu: utilisateur non trouvé dans le bloc de clés\n"
+msgstr "lid %lu : utilisateur non trouvé dans le bloc de clés\n"
#: g10/trustdb.c:1921
#, c-format
msgid "lid %lu: user id without signature\n"
-msgstr "lid %lu: utilisateur sans signature\n"
+msgstr "lid %lu : utilisateur sans signature\n"
#: g10/trustdb.c:1928
#, c-format
msgid "lid %lu: self-signature in hintlist\n"
-msgstr "lid %lu: auto-signature dans la liste d'aide\n"
+msgstr "lid %lu : auto-signature dans la liste d'aide\n"
#: g10/trustdb.c:1939 g10/trustdb.c:2658 g10/trustdb.c:2742
-#, fuzzy
msgid "Valid certificate revocation"
-msgstr "Mauvais certificat"
+msgstr "Certificat de révocation valide"
#: g10/trustdb.c:1940 g10/trustdb.c:2659 g10/trustdb.c:2743
-#, fuzzy
msgid "Good certificate"
-msgstr "Mauvais certificat"
+msgstr "Bon certificat"
#: g10/trustdb.c:1949
msgid "very strange: no public key\n"
-msgstr ""
+msgstr "très étrange : pas de clé publique\n"
#: g10/trustdb.c:1997
#, c-format
msgid "hintlist %lu[%d] of %lu does not point to a dir record\n"
msgstr ""
"la liste d'aide de %lu[%d] de %lu ne pointe pas vers un enregistrement\n"
"de répertoire\n"
#: g10/trustdb.c:2003
#, c-format
msgid "lid %lu does not have a key\n"
msgstr "la lid %lu n'a pas de clé\n"
#: g10/trustdb.c:2013
#, c-format
msgid "lid %lu: can't get keyblock: %s\n"
msgstr "lid %lu: ne peut obtenir le bloc de clés: %s\n"
#: g10/trustdb.c:2070 g10/trustdb.c:2984
-#, fuzzy, c-format
+#, c-format
msgid "tdbio_search_dir failed: %s\n"
-msgstr "suppression d'armure non réussie: %s\n"
+msgstr "tdbio_search_dir a échoué : %s\n"
#: g10/trustdb.c:2223
-#, fuzzy, c-format
+#, c-format
msgid "key %08lX.%lu: Good subkey binding\n"
-msgstr "clé %08lX: mauvaise association avec %08lX\n"
+msgstr "clé %08lX.%lu : bonne liaison avec la sous-clé\n"
#: g10/trustdb.c:2229 g10/trustdb.c:2271
-#, fuzzy, c-format
+#, c-format
msgid "key %08lX.%lu: Invalid subkey binding: %s\n"
-msgstr "clé %08lX: pas de nom d'utilisateur valide\n"
+msgstr "clé %08lX.%lu : liaison avec la sous-clé invalide : %s\n"
#: g10/trustdb.c:2244
-#, fuzzy, c-format
+#, c-format
msgid "key %08lX.%lu: Valid key revocation\n"
-msgstr "clé %08lX: mauvaise révocation de clé par %08lX\n"
+msgstr "clé %08lX.%lu : révocation de clé valide\n"
#: g10/trustdb.c:2250
-#, fuzzy, c-format
+#, c-format
msgid "key %08lX.%lu: Invalid key revocation: %s\n"
-msgstr "clé %08lX: mauvaise révocation de clé par %08lX\n"
+msgstr "clé %08lX.%lu : révocation de sous-clé invalide : %s\n"
#: g10/trustdb.c:2265
-#, fuzzy, c-format
+#, c-format
msgid "key %08lX.%lu: Valid subkey revocation\n"
-msgstr "clé %08lX: mauvaise révocation de sous-clé par %08lX\n"
+msgstr "clé %08lX.%lu : révocation de sous-clé valide\n"
#: g10/trustdb.c:2365
-#, fuzzy
msgid "Good self-signature"
-msgstr "[auto-signature]"
+msgstr "Bonne auto-signature"
#: g10/trustdb.c:2376
-#, fuzzy
msgid "Invalid self-signature"
-msgstr "clé %08lX: auto-signature invalide\n"
+msgstr "Auto-signature invalide"
#: g10/trustdb.c:2386
msgid "Valid user ID revocation skipped due to a newer self signature\n"
msgstr ""
+"La révocation valide de nom d'utilisateur a été ignorée car l'auto-\n"
+"signature est plus récente\n"
#: g10/trustdb.c:2393
-#, fuzzy
msgid "Valid user ID revocation\n"
-msgstr "Choix invalide.\n"
+msgstr "Révocation de nom d'utilisateur valide\n"
#: g10/trustdb.c:2400
-#, fuzzy
msgid "Invalid user ID revocation"
-msgstr "Choix invalide.\n"
+msgstr "Révocation de nom d'utilisateur invalide"
#: g10/trustdb.c:2484
-#, fuzzy
msgid "Too many preferences"
-msgstr "lister les préférences"
+msgstr "Trop de préférences"
#: g10/trustdb.c:2498
-#, fuzzy
msgid "Too many preference items"
-msgstr "lister les préférences"
+msgstr "Trop d'items de préférence"
#: g10/trustdb.c:2637
msgid "Duplicated certificate - deleted"
-msgstr ""
+msgstr "Certificat dupliqué - enlevé"
#: g10/trustdb.c:2670
-#, fuzzy
msgid "Hmmm, public key lost?"
-msgstr "Mauvaise clé publique"
+msgstr "Hmmm, clé publique perdue ?"
#: g10/trustdb.c:2680 g10/trustdb.c:2763
-#, fuzzy
msgid "Invalid certificate revocation"
-msgstr "Mauvais certificat"
+msgstr "Révocation de certificat invalide"
#: g10/trustdb.c:2681 g10/trustdb.c:2764
-#, fuzzy
msgid "Invalid certificate"
-msgstr "Mauvais certificat"
+msgstr "Certificat invalide"
#: g10/trustdb.c:2696
-#, fuzzy, c-format
+#, c-format
msgid "uid %08lX.%lu/%02X%02X: has shadow dir %lu but is not yet marked.\n"
msgstr ""
-"clé %08lX.%lu, uid %02X%02X: possède une ombre %lu mais pas encore\n"
-"marquée.\n"
+"uid %08lX.%lu/%02X%02X : possède une ombre %lu mais n'est pas encore\n"
+"marqué.\n"
#: g10/trustdb.c:2710
-#, fuzzy, c-format
+#, c-format
msgid "sig record %lu[%d] points to wrong record.\n"
msgstr ""
-"l'enregistrement de signature %lu[%d] dans la liste d'aide de %u ne pointe\n"
-"pas vers un enregistrement de répertoire\n"
+"l'enregistrement de signature %lu[%d] pointe vers le mauvais\n"
+"enregistrement de répertoire\n"
#. that should never happen
#: g10/trustdb.c:2954
-#, fuzzy, c-format
+#, c-format
msgid "insert_trust_record: keyblock not found: %s\n"
-msgstr "clé %08lX: clé secrète pas trouvée: %s\n"
+msgstr "insert_trust_record : bloc de clés non trouvé : %s\n"
#: g10/trustdb.c:2972
msgid "did not use primary key for insert_trust_record()\n"
-msgstr ""
+msgstr "n'a pas utilisé la clé principale pour « insert_trust_record() »\n"
#: g10/ringedit.c:293
-#, fuzzy, c-format
+#, c-format
msgid "%s: can't create keyring: %s\n"
-msgstr "%s: ne peut créer: %s\n"
+msgstr "%s : ne peut créer le porte-clés : %s\n"
#: g10/ringedit.c:299 g10/ringedit.c:1264
-#, fuzzy, c-format
+#, c-format
msgid "%s: keyring created\n"
-msgstr "%s: nouveau fichier d'options créé\n"
+msgstr "%s : porte-clés créé\n"
#: g10/ringedit.c:1449
msgid "WARNING: 2 files with confidential information exists.\n"
msgstr ""
+"ATTENTION : 2 fichiers avec des informations confidentielles existent.\n"
#: g10/ringedit.c:1450
-#, fuzzy, c-format
+#, c-format
msgid "%s is the unchanged one\n"
-msgstr " clés secrètes inchangées: %lu\n"
+msgstr "%s est le fichier original\n"
#: g10/ringedit.c:1451
#, c-format
msgid "%s is the new one\n"
-msgstr ""
+msgstr "%s est le nouveau\n"
#: g10/ringedit.c:1452
msgid "Please fix this possible security flaw\n"
-msgstr ""
+msgstr "Réparez ce problème de sécurité possible\n"
#: g10/skclist.c:94
-#, fuzzy, c-format
+#, c-format
msgid "skipped '%s': %s\n"
-msgstr "%s: sauté: %s\n"
+msgstr "'%s' a été ignoré : %s\n"
#: g10/skclist.c:100
-#, fuzzy, c-format
+#, c-format
msgid ""
"skipped '%s': this is a PGP generated ElGamal key which is not secure for "
"signatures!\n"
msgstr ""
-"Cela est une clé ElGamal générée par PGP qui n'est PAS sûre pour les\n"
-"signatures!\n"
+"'%s' a été ignorée : c'est une clé ElGamal générée par PGP qui n'est pas\n"
+"sûre pour les signatures !\n"
#. do not overwrite
#: g10/openfile.c:58
#, c-format
msgid "File '%s' exists. "
msgstr "Le fichier '%s' existe. "
#: g10/openfile.c:60
msgid "Overwrite (y/N)? "
msgstr "Réécrire (o/N)? "
#: g10/openfile.c:85
msgid "writing to stdout\n"
msgstr "écriture vers la sortie standard\n"
#: g10/openfile.c:134
#, c-format
msgid "assuming signed data in '%s'\n"
msgstr "les données signées sont supposées être dans '%s'\n"
#: g10/openfile.c:181
#, c-format
msgid "%s: new options file created\n"
-msgstr "%s: nouveau fichier d'options créé\n"
+msgstr "%s : nouveau fichier d'options créé\n"
#: g10/encr-data.c:59
-#, fuzzy, c-format
+#, c-format
msgid "%s encrypted data\n"
-msgstr "crypter les données"
+msgstr "données chiffrées avec %s\n"
#: g10/encr-data.c:61
#, c-format
msgid "encrypted with unknown algorithm %d\n"
-msgstr ""
+msgstr "chiffré avec l'algorithme inconnu %d\n"
#: g10/encr-data.c:74
-#, fuzzy
msgid ""
"WARNING: Message was encrypted with a weak key in the symmetric cipher.\n"
msgstr ""
-"Attention: Le message a été crypté avec une mauvaise clé pendant le\n"
+"ATTENTION : Le message a été chiffré avec une mauvaise clé pendant le\n"
"chiffrement symétrique.\n"
#: g10/seskey.c:52
msgid "weak key created - retrying\n"
msgstr "mauvaise clé générée - nouvel essai\n"
#: g10/seskey.c:57
#, c-format
msgid "cannot avoid weak key for symmetric cipher; tried %d times!\n"
msgstr ""
-"ne peut éviter une mauvaise clé pour le chiffrement symétrique: \n"
+"ne peut éviter une mauvaise clé pour le chiffrement symétrique : \n"
"%d essais ont eu lieu!\n"
#. begin of list
-#: g10/helptext.c:45
+#: g10/helptext.c:48
msgid "edit_ownertrust.value"
msgstr ""
-"C'est à vous d'assigner une valeur ici; cette valeur ne sera jamais\n"
-"exportée à une tierce personne. Nous en avons besoin pour créer le;\n"
-"réseau de confiance (web-of-trust); cela n'a rien à voir avec le\n"
+"C'est à vous d'assigner une valeur ici ; cette valeur ne sera jamais\n"
+"exportée à une tierce personne. Nous en avons besoin pour créer le\n"
+"réseau de confiance (web-of-trust) ; cela n'a rien à voir avec le\n"
"réseau de certificats (créé implicitement)"
-#: g10/helptext.c:51
+#: g10/helptext.c:54
msgid "revoked_key.override"
msgstr ""
-"Si vous voulez utiliser cette clé révoquée quand-même, répondez \"oui\"."
+"Si vous voulez utiliser cette clé révoquée quand-même, répondez « oui »."
-#: g10/helptext.c:55
+#: g10/helptext.c:58
msgid "untrusted_key.override"
msgstr ""
-"Si vous voulez utiliser cette clé peu sûre quand-même, répondez \"oui\"."
+"Si vous voulez utiliser cette clé peu sûre quand-même, répondez « oui »."
-#: g10/helptext.c:59
+#: g10/helptext.c:62
msgid "pklist.user_id.enter"
-msgstr "Entrez le nom de l'adresse à qui vous voulez envoyer le message."
+msgstr "Entrez l'adresse de la personne à qui vous voulez envoyer le message."
-#: g10/helptext.c:63
+#: g10/helptext.c:66
msgid "keygen.algo"
msgstr "Sélectionnez l'algorithme à utiliser:"
-#: g10/helptext.c:79
-#, fuzzy
+#: g10/helptext.c:82
msgid "keygen.algo.elg_se"
-msgstr "Sélectionnez l'algorithme à utiliser:"
+msgstr ""
+"Bien que ces clés soient définies dans la RFC2440 elles ne sont pas\n"
+"conseillées car tous les programmes ne les supportent pas et les signatures\n"
+"créées avec elles sont plutôt longues et très lentes à vérifier."
-#: g10/helptext.c:86
+#: g10/helptext.c:89
msgid "keygen.size"
msgstr ""
-#: g10/helptext.c:90
+#: g10/helptext.c:93
msgid "keygen.size.huge.okay"
msgstr ""
-#: g10/helptext.c:95
+#: g10/helptext.c:98
msgid "keygen.size.large.okay"
msgstr ""
-#: g10/helptext.c:100
+#: g10/helptext.c:103
msgid "keygen.valid"
msgstr ""
-#: g10/helptext.c:104
+#: g10/helptext.c:107
msgid "keygen.valid.okay"
msgstr ""
-#: g10/helptext.c:109
+#: g10/helptext.c:112
msgid "keygen.name"
msgstr ""
-#: g10/helptext.c:114
+#: g10/helptext.c:117
msgid "keygen.email"
msgstr ""
-#: g10/helptext.c:118
+#: g10/helptext.c:121
msgid "keygen.comment"
msgstr ""
-#: g10/helptext.c:123
+#: g10/helptext.c:126
msgid "keygen.userid.cmd"
msgstr ""
"N pour changer le nom.\n"
"C pour changer le commentaire.\n"
"E pour changer l'adresse e-mail.\n"
"O pour continuer à générer la clé.\n"
"Q pour arrêter de générer de clé."
-#: g10/helptext.c:132
+#: g10/helptext.c:135
msgid "keygen.sub.okay"
-msgstr "Répondez \"oui\" (ou simplement \"o\") pour générer la sous-clé"
+msgstr "Répondez « oui » (ou simplement « o ») pour générer la sous-clé"
-#: g10/helptext.c:136
+#: g10/helptext.c:139
msgid "sign_uid.okay"
msgstr ""
-#: g10/helptext.c:141
+#: g10/helptext.c:144
msgid "change_passwd.empty.okay"
msgstr ""
-#: g10/helptext.c:146
+#: g10/helptext.c:149
msgid "keyedit.cmd"
-msgstr "Entrez \"aide\" s'il vous plaît."
+msgstr "Entrez « aide » pour voir la liste des commandes."
-#: g10/helptext.c:150
+#: g10/helptext.c:153
msgid "keyedit.save.okay"
msgstr ""
-#: g10/helptext.c:155
+#: g10/helptext.c:158
msgid "keyedit.cancel.okay"
msgstr ""
-#: g10/helptext.c:159
+#: g10/helptext.c:162
msgid "keyedit.sign_all.okay"
msgstr ""
-#: g10/helptext.c:163
+#: g10/helptext.c:166
msgid "keyedit.remove.uid.okay"
msgstr ""
-#: g10/helptext.c:168
+#: g10/helptext.c:171
msgid "keyedit.remove.subkey.okay"
msgstr ""
-#: g10/helptext.c:172
+#: g10/helptext.c:175
msgid "passphrase.enter"
msgstr ""
-"Entrez le mot de passe; c'est une phrase secrète \n"
+"Entrez le mot de passe ; c'est une phrase secrète \n"
" Blurb, blurb,.... "
-#: g10/helptext.c:179
+#: g10/helptext.c:182
msgid "passphrase.repeat"
msgstr ""
"Répétez le dernier mot de passe, pour être sûr de ce que vous avez tapé."
-#: g10/helptext.c:183
+#: g10/helptext.c:186
msgid "detached_signature.filename"
msgstr ""
-#: g10/helptext.c:187
+#: g10/helptext.c:190
msgid "openfile.overwrite.okay"
msgstr ""
-#: g10/helptext.c:201
+#: g10/helptext.c:204
msgid "No help available"
msgstr "Pas d'aide disponible"
-#: g10/helptext.c:213
+#: g10/helptext.c:216
#, c-format
msgid "No help available for '%s'"
msgstr "Pas d'aide disponible pour '%s'"
-#~ msgid "You will see a list of signators etc. here\n"
-#~ msgstr "Vous verrez une liste de signataires etc. ici\n"
-
-#~ msgid "key %08lX.%lu, uid %02X%02X, sig %08lX: Good signature (3)\n"
-#~ msgstr "clé %08lX.%lu, uid %02X%02X, sig %08lX: Bonne signature (3)\n"
-
-#~ msgid ""
-#~ "key %08lX.%lu, uid %02X%02X, sig %08lX: very strange: no public key\n"
-#~ msgstr ""
-#~ "clé %08lX.%lu, uid %02X%02X, sig %08lX: très étrange: pas de clé publique\n"
-
-#~ msgid "key %08lX.%lu, uid %02X%02X, sig %08lX: %s\n"
-#~ msgstr "clé %08lX.%lu, uid %02X%02X, sig %08lX: %s\n"
-
-#~ msgid "key %08lX.%lu, uid %02X%02X: Good self-signature\n"
-#~ msgstr "clé %08lX.%lu, uid %02X%02X: Bonne auto-signature\n"
-
-#~ msgid "key %08lX, uid %02X%02X: Invalid self-signature: %s\n"
-#~ msgstr "clé %08lX.%lu, uid %02X%02X: Auto-signature invalide: %s\n"
-
-#~ msgid ""
-#~ "key %08lX.%lu, uid %02X%02X, sig %08lX: duplicated signature - deleted\n"
-#~ msgstr ""
-#~ "clé %08lX.%lu, uid %02X%02X, sig %08lX: signature dupliquée - effacée\n"
-
-#~ msgid "key %08lX.%lu, uid %02X%02X, sig %08lX: Good signature (1)\n"
-#~ msgstr "clé %08lX.%lu, uid %02X%02X, sig %08lX: Bonne signature (1)\n"
-
-#~ msgid "key %08lX.%lu, uid %02X%02X, sig %08lX: weird: no public key\n"
-#~ msgstr ""
-#~ "clé %08lX.%lu, uid %02X%02X, sig %08lX: bizarre: pas de clé publique\n"
-
-#~ msgid "key %08lX.%lu, uid %02X%02X, sig %08lX: Good signature (2)\n"
-#~ msgstr "clé %08lX.%lu, uid %02X%02X, sig %08lX: Bonne signature (2)\n"
-
-#~ msgid "key %08lX.%lu, uid %02X%02X, sig %08lX: no public key\n"
-#~ msgstr "clé %08lX.%lu, uid %02X%02X, sig %08lX: pas de clé publique\n"
diff --git a/po/it.po b/po/it.po
index cacbb10ff..752a31a7f 100644
--- a/po/it.po
+++ b/po/it.po
@@ -1,3066 +1,3066 @@
# SOME DESCRIPTIVE TITLE.
# Copyright (C) 1998 Free Software Foundation, Inc.
# Marco d'Itri <md@linux.it>, 1998.
#
msgid ""
msgstr ""
"Project-Id-Version: gnupg-0.4.3\n"
"POT-Creation-Date: 1998-12-10 20:11+0100\n"
"PO-Revision-Date: 1998-11-09 16:19+01:00\n"
"Last-Translator: Marco d'Itri <md@linux.it>\n"
"Language-Team: Italian <it@li.org>\n"
"MIME-Version: 1.0\n"
"Content-Type: text/plain; charset=iso-8859-1\n"
"Content-Transfer-Encoding: 8bit\n"
#: util/secmem.c:77
msgid "Warning: using insecure memory!\n"
msgstr "Attenzione: si sta usando memoria insicura!\n"
#: util/miscutil.c:143
msgid "yes"
msgstr "sì"
#: util/miscutil.c:144
msgid "yY"
msgstr "sS"
#: util/errors.c:54
msgid "General error"
msgstr "Errore generale"
#: util/errors.c:55
msgid "Unknown packet type"
msgstr "Tipo del pacchetto sconosciuto"
#: util/errors.c:56
msgid "Unknown version"
msgstr "Versione sconosciuta"
#: util/errors.c:57
msgid "Unknown pubkey algorithm"
msgstr "Algoritmo della chiave pubblica sconosciuto"
#: util/errors.c:58
msgid "Unknown digest algorithm"
msgstr "Algoritmo del digest sconosciuto"
#: util/errors.c:59
msgid "Bad public key"
msgstr "Chiave pubblica errata o danneggiata"
#: util/errors.c:60
msgid "Bad secret key"
msgstr "Chiave segreta errata o danneggiata"
#: util/errors.c:61
msgid "Bad signature"
msgstr "Firma errata o danneggiata"
#: util/errors.c:62
msgid "Checksum error"
msgstr "Checksum errato"
#: util/errors.c:63
msgid "Bad passphrase"
msgstr "Passphrase errata"
#: util/errors.c:64
msgid "Public key not found"
msgstr "Chiave pubblica non trovata"
#: util/errors.c:65
msgid "Unknown cipher algorithm"
msgstr "Algoritmo di cifratura sconosciuto"
#: util/errors.c:66
msgid "Can't open the keyring"
msgstr "Impossibile aprire il portachiavi"
#: util/errors.c:67
msgid "Invalid packet"
msgstr "Pacchetto non valido"
#: util/errors.c:68
msgid "Invalid armor"
msgstr "Armatura non valida"
#: util/errors.c:69
msgid "No such user id"
msgstr "User id inesistente"
#: util/errors.c:70
msgid "Secret key not available"
msgstr "La chiave segreta non è disponibile."
#: util/errors.c:71
msgid "Wrong secret key used"
msgstr "È stata usata la chiave segreta sbagliata"
#: util/errors.c:72
msgid "Not supported"
msgstr "Non gestito"
#: util/errors.c:73
msgid "Bad key"
msgstr "Chiave danneggiata"
#: util/errors.c:74
msgid "File read error"
msgstr "Errore durante la lettura del file"
#: util/errors.c:75
msgid "File write error"
msgstr "Errore durante la scrittura del file"
#: util/errors.c:76
msgid "Unknown compress algorithm"
msgstr "Algoritmo di compressione sconosciuto"
#: util/errors.c:77
msgid "File open error"
msgstr "Errore durante l'apertura del file"
#: util/errors.c:78
msgid "File create error"
msgstr "Errore durante la creazione del file"
#: util/errors.c:79
msgid "Invalid passphrase"
msgstr "Passphrase non valida"
#: util/errors.c:80
msgid "Unimplemented pubkey algorithm"
msgstr "Algoritmo della chiave pubblica non implementato"
#: util/errors.c:81
msgid "Unimplemented cipher algorithm"
msgstr "Algoritmo di cifratura non implementato"
#: util/errors.c:82
msgid "Unknown signature class"
msgstr "Classe della firma sconosciuta."
#: util/errors.c:83
msgid "Trust database error"
msgstr "Errore nel database della fiducia"
#: util/errors.c:84
msgid "Bad MPI"
msgstr "MPI danneggiato"
#: util/errors.c:85
msgid "Resource limit"
msgstr "Limite della risorsa"
#: util/errors.c:86
msgid "Invalid keyring"
msgstr "Portachiavi non valido"
#: util/errors.c:87
msgid "Bad certificate"
msgstr "Certificato danneggiato"
#: util/errors.c:88
msgid "Malformed user id"
msgstr "User id malformato"
#: util/errors.c:89
msgid "File close error"
msgstr "Errore durante la chiusura del file"
#: util/errors.c:90
msgid "File rename error"
msgstr "Errore durante la rinominazione del file"
#: util/errors.c:91
msgid "File delete error"
msgstr "Errore durante la cancellazione del file"
#: util/errors.c:92
msgid "Unexpected data"
msgstr "Dati inaspettati"
#: util/errors.c:93
msgid "Timestamp conflict"
msgstr "Date in conflitto"
#: util/errors.c:94
msgid "Unusable pubkey algorithm"
msgstr "Algoritmo della chiave pubblica non utilizzabile"
#: util/errors.c:95
msgid "File exists"
msgstr "Il file esiste"
#: util/errors.c:96
msgid "Weak key"
msgstr "Chiave debole"
#: util/logger.c:178
#, c-format
msgid "... this is a bug (%s:%d:%s)\n"
msgstr "... questo è un bug (%s:%d:%s)\n"
#: util/logger.c:184
#, c-format
msgid "you found a bug ... (%s:%d)\n"
msgstr "Hai trovato un bug... (%s:%d)\n"
#: cipher/random.c:412
#, fuzzy
msgid "WARNING: using insecure random number generator!!\n"
msgstr ""
"Attenzione: si sta usando un generatore di numeri casuali non sicuro!!\n"
#: cipher/random.c:413
msgid ""
"The random number generator is only a kludge to let\n"
"it run - it is in no way a strong RNG!\n"
"\n"
"DON'T USE ANY DATA GENERATED BY THIS PROGRAM!!\n"
"\n"
msgstr ""
"Il generatore di numeri casuali è solo un ripiego per fare\n"
"compilare il programma - non è assolutamente un RNG forte!\n"
#: cipher/rndlinux.c:116
#, c-format
msgid ""
"\n"
"Not enough random bytes available. Please do some other work to give\n"
"the OS a chance to collect more entropy! (Need %d more bytes)\n"
msgstr ""
"\n"
"Non ci sono abbastanza byte casuali disponibili. Per favore fai qualche\n"
"altra cosa per dare all'OS la possibilità di raccogliere altra entropia!\n"
"(Servono ancora %d altri byte)\n"
#: g10/g10.c:159
msgid ""
"@Commands:\n"
" "
msgstr ""
"@Comandi:\n"
" "
#: g10/g10.c:162
msgid "|[file]|make a signature"
msgstr "|[file]|fai una firma"
#: g10/g10.c:163
msgid "|[file]|make a clear text signature"
msgstr "|[file]|fai una firma mantenendo il testo in chiaro"
#: g10/g10.c:164
msgid "make a detached signature"
msgstr "fai una firma separata"
#: g10/g10.c:165
msgid "encrypt data"
msgstr "cifra dati"
#: g10/g10.c:166
msgid "encryption only with symmetric cipher"
msgstr "cifra solo con un cifrario simmetrico"
#: g10/g10.c:167
msgid "store only"
msgstr "immagazzina soltanto"
#: g10/g10.c:168
msgid "decrypt data (default)"
msgstr "decifra dati (predefinito)"
#: g10/g10.c:169
msgid "verify a signature"
msgstr "verifica una firma"
#: g10/g10.c:171
msgid "list keys"
msgstr "elenca le chiavi"
#: g10/g10.c:172
msgid "list keys and signatures"
msgstr "elenca le chiavi e le firme"
#: g10/g10.c:173
msgid "check key signatures"
msgstr "controlla le firme delle chiavi"
#: g10/g10.c:174
msgid "list keys and fingerprints"
msgstr "elenca le chiavi e le impronte digitali"
#: g10/g10.c:175
msgid "list secret keys"
msgstr "elenca le chiavi segrete"
#: g10/g10.c:177
msgid "generate a new key pair"
msgstr "genera una nuova coppia di chiavi"
#: g10/g10.c:179
msgid "remove key from the public keyring"
msgstr "rimuove una chiave dal portachiavi pubblico"
#: g10/g10.c:181
msgid "sign or edit a key"
msgstr "firma o modifica una chiave"
#: g10/g10.c:182
msgid "generate a revocation certificate"
msgstr "genera un certificato di revoca"
#: g10/g10.c:184
msgid "export keys"
msgstr "esporta delle chiavi"
#: g10/g10.c:187
msgid "import/merge keys"
msgstr "importa/aggiungi delle chiavi"
#: g10/g10.c:189
msgid "list only the sequence of packets"
msgstr "elenca solo la sequenza dei pacchetti"
#: g10/g10.c:192
msgid "export the ownertrust values"
msgstr "esporta i valori di fiducia"
#: g10/g10.c:194
msgid "import ownertrust values"
msgstr "importa i valori di fiducia"
#: g10/g10.c:196
msgid "|[NAMES]|update the trust database"
msgstr "|[NAMES]|controlla il database della fiducia"
#: g10/g10.c:198
msgid "|[NAMES]|check the trust database"
msgstr "|[NAMES]|controlla il database della fiducia"
#: g10/g10.c:199
msgid "fix a corrupted trust database"
msgstr "ripara un database della fiducia rovinato"
#: g10/g10.c:200
msgid "De-Armor a file or stdin"
msgstr "rimuovi l'armatura a un file o a stdin"
#: g10/g10.c:201
msgid "En-Armor a file or stdin"
msgstr "crea l'armatura a un file o a stdin"
#: g10/g10.c:202
msgid "|algo [files]|print message digests"
msgstr "|algo [files]|stampa tutti i message digests"
#: g10/g10.c:203
msgid "print all message digests"
msgstr "stampa tutti i message digests"
#: g10/g10.c:210
msgid ""
"@\n"
"Options:\n"
" "
msgstr ""
"@\n"
"Opzioni:\n"
" "
#: g10/g10.c:212
msgid "create ascii armored output"
msgstr "crea un output ascii con armatura"
#: g10/g10.c:214
msgid "use this user-id to sign or decrypt"
msgstr "usa questo user-id per firmare o decifrare"
#: g10/g10.c:215
msgid "use this user-id for encryption"
msgstr "usa questo user-id per cifrare"
#: g10/g10.c:216
msgid "|N|set compress level N (0 disables)"
msgstr "|N|imposta il livello di compressione (0 disabilita)"
#: g10/g10.c:218
msgid "use canonical text mode"
msgstr "usa il modo testo canonico"
#: g10/g10.c:220
msgid "use as output file"
msgstr "usa come file di output"
#: g10/g10.c:221
msgid "verbose"
msgstr "prolisso"
#: g10/g10.c:222
msgid "be somewhat more quiet"
msgstr "meno prolisso"
#: g10/g10.c:223
msgid "force v3 signatures"
msgstr "forza l'uso di firme v3"
#. { oDryRun, "dry-run", 0, N_("do not make any changes") },
#: g10/g10.c:225
msgid "batch mode: never ask"
msgstr "modo batch: non fare domande"
#: g10/g10.c:226
msgid "assume yes on most questions"
msgstr "assumi \"sì\" a quasi tutte le domande"
#: g10/g10.c:227
msgid "assume no on most questions"
msgstr "assumi \"no\" a quasi tutte le domande"
#: g10/g10.c:228
msgid "add this keyring to the list of keyrings"
msgstr "aggiungi questo portachiavi alla lista"
#: g10/g10.c:229
msgid "add this secret keyring to the list"
msgstr "aggiungi questo portachiavi segreto alla lista"
#: g10/g10.c:230
msgid "|NAME|use NAME as default secret key"
msgstr "|NAME|usa NAME come chiave segreta predefinita"
#: g10/g10.c:231
#, fuzzy
msgid "|NAME|set terminal charset to NAME"
msgstr "|NAME|usa l'algoritmo di cifratura NOME"
#: g10/g10.c:232
msgid "read options from file"
msgstr "leggi le opzioni dal file"
#: g10/g10.c:234
msgid "set debugging flags"
msgstr "imposta i flag di debugging"
#: g10/g10.c:235
msgid "enable full debugging"
msgstr "abilita il debugging completo"
#: g10/g10.c:236
msgid "|FD|write status info to this FD"
msgstr "|FD|scrivi le informazioni di stato su questo fd"
#: g10/g10.c:237
msgid "do not write comment packets"
msgstr "non scrivere pacchetti di commento"
#: g10/g10.c:238
msgid "(default is 1)"
msgstr "(predefinito è 1)"
#: g10/g10.c:239
msgid "(default is 3)"
msgstr "(predefinito è 3)"
#: g10/g10.c:241
msgid "|KEYID|ulimately trust this key"
msgstr ""
#: g10/g10.c:242
msgid "|FILE|load extension module FILE"
msgstr "|FILE|carica il modulo di estensione FILE"
#: g10/g10.c:243
msgid "emulate the mode described in RFC1991"
msgstr "emula il modo descritto nel RFC1991"
#: g10/g10.c:244
msgid "|N|use passphrase mode N"
msgstr "|N|usa il modo N per la passphrase"
#: g10/g10.c:246
msgid "|NAME|use message digest algorithm NAME for passphrases"
msgstr "|NAME|usa l'algoritmo di message digest NOME"
#: g10/g10.c:248
msgid "|NAME|use cipher algorithm NAME for passphrases"
msgstr "|NAME|usa l'alg. di cifratura NOME per le passphrase"
#: g10/g10.c:250
msgid "|NAME|use cipher algorithm NAME"
msgstr "|NAME|usa l'algoritmo di cifratura NOME"
#: g10/g10.c:251
msgid "|NAME|use message digest algorithm NAME"
msgstr "|NAME|usa l'algoritmo di message digest NOME"
#: g10/g10.c:252
msgid "|N|use compress algorithm N"
msgstr "|N|usa l'algoritmo di compressione N"
#: g10/g10.c:253
msgid "throw keyid field of encrypted packets"
msgstr "elimina il campo keyid dei pacchetti crittografati"
#: g10/g10.c:261
msgid ""
"@\n"
"Examples:\n"
"\n"
" -se -r Bob [file] sign and encrypt for user Bob\n"
" --clearsign [file] make a clear text signature\n"
" --detach-sign [file] make a detached signature\n"
" --list-keys [names] show keys\n"
" --fingerprint [names] show fingerprints\n"
msgstr ""
"@\n"
"Esempi:\n"
"\n"
" -se -r Bob [file] firma e cifra per l'utente Bob\n"
" --clearsign [file] fai una firma mantenendo il testo in chiaro\n"
" --detach-sign [file] fai una firma separata\n"
" --list-keys [nomi] mostra le chiavi\n"
" --fingerprint [nomi] mostra le impronte digitali\n"
#: g10/g10.c:339
msgid "Please report bugs to <gnupg-bugs@gnu.org>.\n"
msgstr "Per favore segnala i bug a <gnupg-bugs@gnu.org>.\n"
#: g10/g10.c:344
msgid "Usage: gpgm [options] [files] (-h for help)"
msgstr "Uso: gpgm [opzioni] [file] (-h per l'aiuto)"
#: g10/g10.c:346
msgid "Usage: gpg [options] [files] (-h for help)"
msgstr "Uso: gpg [opzioni] [file] (-h per l'aiuto)"
#: g10/g10.c:351
msgid ""
"Syntax: gpgm [options] [files]\n"
"GnuPG maintenance utility\n"
msgstr ""
"Sintassi: gpgm [opzioni] [file]\n"
"Utility di manutenzione di GnuPG\n"
#: g10/g10.c:354
msgid ""
"Syntax: gpg [options] [files]\n"
"sign, check, encrypt or decrypt\n"
"default operation depends on the input data\n"
msgstr ""
"Sintassi: gpg [opzioni] [file]\n"
"firma, controlla, cifra o decifra\n"
"l'operazione predefinita dipende dai dati di input\n"
#: g10/g10.c:360
msgid ""
"\n"
"Supported algorithms:\n"
msgstr ""
"\n"
"Algoritmi gestiti:\n"
#: g10/g10.c:435
msgid "usage: gpgm [options] "
msgstr "uso: gpgm [options] "
#: g10/g10.c:437
msgid "usage: gpg [options] "
msgstr "uso: gpg [options] "
#: g10/g10.c:478
msgid "conflicting commands\n"
msgstr "comandi in conflitto\n"
#: g10/g10.c:616
#, fuzzy, c-format
msgid "NOTE: no default option file '%s'\n"
msgstr "nota: nessun file con opzioni predefinite '%s'\n"
#: g10/g10.c:620
#, c-format
msgid "option file '%s': %s\n"
msgstr "file con opzioni predefinite '%s': %s\n"
#: g10/g10.c:627
#, c-format
msgid "reading options from '%s'\n"
msgstr "lettura delle opzioni da '%s'\n"
#: g10/g10.c:776
#, fuzzy, c-format
msgid "%s is not a valid character set\n"
msgstr "Carattere non valido nel commento\n"
#: g10/g10.c:810 g10/g10.c:822
msgid "selected cipher algorithm is invalid\n"
msgstr "l'algoritmo di cifratura selezionato non è valido\n"
#: g10/g10.c:816 g10/g10.c:828
msgid "selected digest algorithm is invalid\n"
msgstr "l'algoritmo di digest selezionato non è valido\n"
#: g10/g10.c:831
#, c-format
msgid "compress algorithm must be in range %d..%d\n"
msgstr "l'algoritmo di compressione deve essere tra %d e %d\n"
#: g10/g10.c:833
msgid "completes-needed must be greater than 0\n"
msgstr "completes-needed deve essere maggiore di 0\n"
#: g10/g10.c:835
msgid "marginals-needed must be greater than 1\n"
msgstr "marginals-needed deve essere maggiore di 1\n"
#: g10/g10.c:837
msgid "max-cert-depth must be in range 1 to 255\n"
msgstr ""
#: g10/g10.c:840
#, fuzzy
msgid "NOTE: simple S2K mode (0) is strongly discouraged\n"
msgstr "nota: il modo S2K semplice (0) è fortemente scoraggiato\n"
#: g10/g10.c:844
msgid "invalid S2K mode; must be 0, 1 or 3\n"
msgstr "modo S2K non valido; deve essere 0, 1 o 3\n"
#: g10/g10.c:927
#, c-format
msgid "failed to initialize the TrustDB: %s\n"
msgstr "inizializzazione del trustdb fallita: %s\n"
#: g10/g10.c:933
msgid "--store [filename]"
msgstr "--store [nomefile]"
#: g10/g10.c:941
msgid "--symmetric [filename]"
msgstr "--symmetric [nomefile]"
#: g10/g10.c:949
msgid "--encrypt [filename]"
msgstr "--encrypt [nomefile]"
#: g10/g10.c:962
msgid "--sign [filename]"
msgstr "--sign [nomefile]"
#: g10/g10.c:975
msgid "--sign --encrypt [filename]"
msgstr "--sign --encrypt [nomefile]"
#: g10/g10.c:989
msgid "--clearsign [filename]"
msgstr "--clearsign [nomefile]"
#: g10/g10.c:1001
msgid "--decrypt [filename]"
msgstr "--decrypt [nomefile]"
#: g10/g10.c:1010
#, fuzzy
msgid "--edit-key username [commands]"
msgstr "--edit-key nomeutente"
#: g10/g10.c:1026
msgid "--delete-secret-key username"
msgstr "--delete-secret-key nomeutente"
#: g10/g10.c:1029
msgid "--delete-key username"
msgstr "--delete-key nomeutente"
#: g10/encode.c:216 g10/g10.c:1052 g10/sign.c:301
#, c-format
msgid "can't open %s: %s\n"
msgstr "impossibile aprire '%s': %s\n"
#: g10/g10.c:1063
msgid "-k[v][v][v][c] [userid] [keyring]"
msgstr "-k[v][v][v][c] [userid] [portachiavi]"
#: g10/g10.c:1120
#, c-format
msgid "dearmoring failed: %s\n"
msgstr "rimozione dell'armatura fallita: %s\n"
#: g10/g10.c:1128
#, c-format
msgid "enarmoring failed: %s\n"
msgstr "creazione dell'armatura fallita: %s\n"
#: g10/g10.c:1194
#, c-format
msgid "invalid hash algorithm '%s'\n"
msgstr "algoritmo di hash non valido '%s'\n"
#: g10/g10.c:1273
msgid "[filename]"
msgstr "[nomefile]"
#: g10/g10.c:1277
msgid "Go ahead and type your message ...\n"
msgstr ""
#: g10/decrypt.c:59 g10/g10.c:1280 g10/verify.c:66
#, c-format
msgid "can't open '%s'\n"
msgstr "impossibile aprire '%s'\n"
#: g10/armor.c:344 g10/armor.c:391
msgid "armor header: "
msgstr "header dell'armatura: "
#: g10/armor.c:355
msgid "invalid clearsig header\n"
msgstr "header della firma in chiaro non valido\n"
#: g10/armor.c:382
msgid "invalid armor header: "
msgstr "header dell'armatura non valido: "
#: g10/armor.c:460
#, c-format
msgid "armor: %s\n"
msgstr "armatura: %s\n"
#: g10/armor.c:533
msgid "invalid dash escaped line: "
msgstr "riga protetta con il trattino non valida: "
#: g10/armor.c:602
msgid "invalid clear text header: "
msgstr "header del testo in chiaro non valido: "
#: g10/armor.c:845
#, c-format
msgid "invalid radix64 character %02x skipped\n"
msgstr "Carattere radix64 non valido %02x saltato\n"
#: g10/armor.c:878
msgid "premature eof (no CRC)\n"
msgstr "eof prematura (nessun CRC)\n"
#: g10/armor.c:897
msgid "premature eof (in CRC)\n"
msgstr "eof prematura (nel CRC)\n"
#: g10/armor.c:901
msgid "malformed CRC\n"
msgstr "CRC malformato\n"
#: g10/armor.c:905
#, c-format
msgid "CRC error; %06lx - %06lx\n"
msgstr "errore nel CRC; %06lx - %06lx\n"
#: g10/armor.c:924
msgid "premature eof (in Trailer)\n"
msgstr "eof prematura (nella coda)\n"
#: g10/armor.c:928
msgid "error in trailer line\n"
msgstr "errore nella riga della coda\n"
#: g10/armor.c:1182
msgid "no valid RFC1991 or OpenPGP data found.\n"
msgstr "Non sono stati trovati dati RFC1991 o OpenPGP validi.\n"
#: g10/pkclist.c:121
#, fuzzy, c-format
msgid ""
"No trust value assigned to %lu:\n"
"%4u%c/%08lX %s \""
msgstr ""
"Nessun valore di fiducia del proprietario definito per %lu:\n"
"%4u%c/%08lX %s \""
#: g10/pkclist.c:131
msgid ""
"Please decide how far you trust this user to correctly\n"
"verify other users' keys (by looking at passports,\n"
"checking fingerprints from different sources...)?\n"
"\n"
" 1 = Don't know\n"
" 2 = I do NOT trust\n"
" 3 = I trust marginally\n"
" 4 = I trust fully\n"
" s = please show me more information\n"
msgstr ""
"Per favore decidi quanto hai fiducia di questo utente perchè firmi\n"
"correttamente le chiavi di altri utenti (guardando il loro passaporto,\n"
"controllando le impronte digitali da diverse fonti ...)?\n"
"\n"
" 1 = Non lo so\n"
" 2 = NON mi fido\n"
" 3 = Mi fido marginalmente\n"
" 4 = Mi fido completamente\n"
" s = mostrami ulteriori informazioni\n"
#: g10/pkclist.c:140
msgid " m = back to the main menu\n"
msgstr " m = ritorna al menù principale\n"
# valid user replies (not including 1..4)
# [Marco, you can change 'm' and 's' to whatever letters you like]
#. a string with valid answers
#: g10/pkclist.c:145
msgid "sSmM"
msgstr "sSmM"
#: g10/pkclist.c:149
msgid "Your decision? "
msgstr "Cosa hai deciso? "
#: g10/pkclist.c:169
msgid "Certificates leading to an ultimately trusted key:\n"
msgstr ""
#: g10/pkclist.c:197
msgid ""
"Could not find a valid trust path to the key. Let's see whether we\n"
"can assign some missing owner trust values.\n"
"\n"
msgstr ""
"Impossibile trovare un percorso di fiducia valido fino alla chiave. Vediamo\n"
"se possiamo assegnare qualche valore di fiducia del proprietario mancante.\n"
"\n"
#: g10/pkclist.c:219
msgid ""
"No path leading to one of our keys found.\n"
"\n"
msgstr ""
#: g10/pkclist.c:221
msgid ""
"No certificates with undefined trust found.\n"
"\n"
msgstr ""
#: g10/pkclist.c:223
#, fuzzy
msgid ""
"No trust values changed.\n"
"\n"
msgstr ""
"Nessun valore di fiducia del proprietario modificato.\n"
"\n"
#: g10/pkclist.c:238
#, fuzzy, c-format
msgid "key %08lX: key has been revoked!\n"
msgstr "chiave %08lX: accettata come chiave segreta\n"
#: g10/pkclist.c:244 g10/pkclist.c:335
msgid "Use this key anyway? "
msgstr "Uso lo stesso questa chiave? "
#: g10/pkclist.c:266
#, fuzzy, c-format
msgid "%08lX: key has expired\n"
msgstr "Nota: questa chiave è scaduta!\n"
#: g10/pkclist.c:272
#, c-format
msgid "%08lX: no info to calculate a trust probability\n"
msgstr ""
#: g10/pkclist.c:288
#, fuzzy, c-format
msgid "%08lX: We do NOT trust this key\n"
msgstr "ATTENZIONE: NON ci fidiamo di questa chiave!\n"
#: g10/pkclist.c:294
#, c-format
msgid ""
"%08lX: It is not sure that this key really belongs to the owner\n"
"but it is accepted anyway\n"
msgstr ""
#: g10/pkclist.c:300
msgid "This key probably belongs to the owner\n"
msgstr ""
#: g10/pkclist.c:305
msgid "This key belongs to us\n"
msgstr ""
#: g10/pkclist.c:330
msgid ""
"It is NOT certain that the key belongs to its owner.\n"
"If you *really* know what you are doing, you may answer\n"
"the next question with yes\n"
"\n"
msgstr ""
"NON è sicuro che la chiave appartenga al suo proprietario.\n"
"Se *veramente* sai cosa stai facendo, puoi rispondere sì alla\n"
"prossima domanda.\n"
"\n"
#: g10/pkclist.c:339
msgid "WARNING: Using untrusted key!\n"
msgstr "ATTENZIONE: uso di una chiave non fidata!\n"
#: g10/pkclist.c:375
msgid "WARNING: This key has been revoked by its owner!\n"
msgstr "ATTENZIONE: questa chiave è stata revocata dal suo proprietario!\n"
#: g10/pkclist.c:376
msgid " This could mean that the signature is forgery.\n"
msgstr " Questo può significare che la firma è stata falsificata.\n"
#: g10/pkclist.c:397
msgid "Note: This key has expired!\n"
msgstr "Nota: questa chiave è scaduta!\n"
#: g10/pkclist.c:404
msgid "WARNING: This key is not certified with a trusted signature!\n"
msgstr "ATTENZIONE: questa chiave non è certificata con una firma fidata!\n"
#: g10/pkclist.c:406
msgid ""
" There is no indication that the signature belongs to the owner.\n"
msgstr ""
" Non ci sono indicazioni che la firma appartenga al proprietario.\n"
#: g10/pkclist.c:421
msgid "WARNING: We do NOT trust this key!\n"
msgstr "ATTENZIONE: NON ci fidiamo di questa chiave!\n"
#: g10/pkclist.c:422
msgid " The signature is probably a FORGERY.\n"
msgstr " La firma è probabilmente un FALSO.\n"
#: g10/pkclist.c:429
msgid ""
"WARNING: This key is not certified with sufficiently trusted signatures!\n"
msgstr ""
"ATTENZIONE: questa chiave non è certificata con firme abbastanza fidate!\n"
#: g10/pkclist.c:432
msgid " It is not certain that the signature belongs to the owner.\n"
msgstr " Non è sicuro che la firma appartenga al proprietario.\n"
#: g10/pkclist.c:477
msgid ""
"You did not specify a user ID. (you may use \"-r\")\n"
"\n"
msgstr ""
"Non hai specificato un user ID. (puoi usare \"-r\")\n"
"\n"
#: g10/pkclist.c:482
msgid "Enter the user ID: "
msgstr "Inserisci l'user ID: "
#: g10/pkclist.c:493
msgid "No such user ID.\n"
msgstr "User ID inesistente.\n"
#: g10/pkclist.c:527 g10/pkclist.c:554
#, c-format
msgid "%s: skipped: %s\n"
msgstr "%s: saltata: %s\n"
#: g10/pkclist.c:535
#, c-format
msgid "%s: error checking key: %s\n"
msgstr "%s: errore nel controllare la chiave: %s\n"
#: g10/pkclist.c:561
msgid "no valid addressees\n"
msgstr "nessun indirizzo valido\n"
#: g10/keygen.c:124
msgid "writing self signature\n"
msgstr "scrittura della autofirma\n"
#: g10/keygen.c:162
msgid "writing key binding signature\n"
msgstr "scrittura della autofirma\n"
#: g10/keygen.c:388
msgid "Please select what kind of key you want:\n"
msgstr "Per favore scegli che tipo di chiave vuoi:\n"
#: g10/keygen.c:390
#, c-format
msgid " (%d) DSA and ElGamal (default)\n"
msgstr " (%d) DSA e ElGamal (default)\n"
#: g10/keygen.c:391
#, c-format
msgid " (%d) DSA (sign only)\n"
msgstr " (%d) DSA (firma solo)\n"
#: g10/keygen.c:393
#, c-format
msgid " (%d) ElGamal (encrypt only)\n"
msgstr " (%d) ElGamal (crittografa solo)\n"
#: g10/keygen.c:394
#, c-format
msgid " (%d) ElGamal (sign and encrypt)\n"
msgstr " (%d) ElGamal (firma e crittografa)\n"
#: g10/keygen.c:396
#, c-format
msgid " (%d) ElGamal in a v3 packet\n"
msgstr " (%d) ElGamal in un pacchetto v3\n"
#: g10/keygen.c:401
msgid "Your selection? "
msgstr "Cosa scegli? "
#: g10/keygen.c:411
#, fuzzy
msgid "Do you really want to create a sign and encrypt key? "
msgstr "Vuoi davvero cancellare le chiavi selezionate? "
#: g10/keygen.c:432
msgid "Invalid selection.\n"
msgstr "Scelta non valida.\n"
#: g10/keygen.c:444
#, c-format
msgid ""
"About to generate a new %s keypair.\n"
" minimum keysize is 768 bits\n"
" default keysize is 1024 bits\n"
" highest suggested keysize is 2048 bits\n"
msgstr ""
"Sto per generare una nuova coppia di chiavi %s.\n"
" la dimensione minima è 768 bit\n"
" la dimensione predefinita è 1024 bit\n"
" la dimensione massima consigliata è 2048 bit\n"
#: g10/keygen.c:451
msgid "What keysize do you want? (1024) "
msgstr "Di che dimensioni vuoi la chiave? (1024) "
#: g10/keygen.c:456
msgid "DSA only allows keysizes from 512 to 1024\n"
msgstr "DSA permette solo chiavi di dimensioni da 512 a 1024\n"
#: g10/keygen.c:458
msgid "keysize too small; 768 is smallest value allowed.\n"
msgstr "la chiave è troppo corta; 768 è il minimo valore permesso.\n"
#: g10/keygen.c:461
msgid ""
"Keysizes larger than 2048 are not suggested because\n"
"computations take REALLY long!\n"
msgstr ""
"Chiavi più lunghe di 2048 non sono consigliate perchè i calcoli sono \n"
"VERAMENTE lunghi!\n"
#: g10/keygen.c:464
msgid "Are you sure that you want this keysize? "
msgstr "Sei sicuro di volere una chiave di queste dimensioni? "
#: g10/keygen.c:465
msgid ""
"Okay, but keep in mind that your monitor and keyboard radiation is also very "
"vulnerable to attacks!\n"
msgstr ""
"Va bene, ma ricordati che anche le radiazioni emesse dal tuo monitor e dalla "
"tua tastiera sono molto vulnerabili ad attacchi!\n"
#: g10/keygen.c:473
msgid "Do you really need such a large keysize? "
msgstr "Ti serve davvero una chiave così lunga? "
#: g10/keygen.c:479
#, c-format
msgid "Requested keysize is %u bits\n"
msgstr "Le dimensioni della chiave richieste sono %u bit\n"
#: g10/keygen.c:482 g10/keygen.c:486
#, c-format
msgid "rounded up to %u bits\n"
msgstr "arrotondate a %u bit\n"
#: g10/keygen.c:499
msgid ""
"Please specify how long the key should be valid.\n"
" 0 = key does not expire\n"
" <n> = key expires in n days\n"
" <n>w = key expires in n weeks\n"
" <n>m = key expires in n months\n"
" <n>y = key expires in n years\n"
msgstr ""
"Per favore specifica per quanto la chiave sarà valida.\n"
" 0 = la chiave non scadrà\n"
" <n>w = la chiave scadrà dopo n giorni\n"
" <n>m = la chiave scadrà dopo n mesi\n"
" <n>y = la chiave scadrà dopo n anni\n"
#: g10/keygen.c:514
msgid "Key is valid for? (0) "
msgstr "Chiave valida per? (0) "
#: g10/keygen.c:525
msgid "invalid value\n"
msgstr "valore non valido\n"
#: g10/keygen.c:530
msgid "Key does not expire at all\n"
msgstr "La chiave non scade\n"
#. print the date when the key expires
#: g10/keygen.c:536
#, c-format
msgid "Key expires at %s\n"
msgstr "La chiave scadrà il %s\n"
#: g10/keygen.c:542
msgid "Is this correct (y/n)? "
msgstr "È giusto (s/n)? "
#: g10/keygen.c:584
msgid ""
"\n"
"You need a User-ID to identify your key; the software constructs the user "
"id\n"
"from Real Name, Comment and Email Address in this form:\n"
" \"Heinrich Heine (Der Dichter) <heinrichh@duesseldorf.de>\"\n"
"\n"
msgstr ""
"\n"
"Ti serve un User ID per identificare la tua chiave; il software costruisce "
"l'user id a partire da Nome e Cognome, Commento e Indirizzo di Email "
"indicati in questa forma:\n"
" \"Heinrich Heine (Der Dichter) <heinrichh@duesseldorf.de>\"\n"
"\n"
#: g10/keygen.c:595
msgid "Real name: "
msgstr "Nome e Cognome: "
#: g10/keygen.c:599
msgid "Invalid character in name\n"
msgstr "Carattere non valido nel nome\n"
#: g10/keygen.c:601
msgid "Name may not start with a digit\n"
msgstr "Il nome non può iniziare con una cifra\n"
#: g10/keygen.c:603
msgid "Name must be at least 5 characters long\n"
msgstr "Il nome deve essere lungo almeno 5 caratteri\n"
#: g10/keygen.c:611
msgid "Email address: "
msgstr "Indirizzo di Email: "
#: g10/keygen.c:623
msgid "Not a valid email address\n"
msgstr "L'indirizzo di email non è valido\n"
#: g10/keygen.c:631
msgid "Comment: "
msgstr "Commento: "
#: g10/keygen.c:637
msgid "Invalid character in comment\n"
msgstr "Carattere non valido nel commento\n"
#: g10/keygen.c:657
#, c-format
msgid ""
"You selected this USER-ID:\n"
" \"%s\"\n"
"\n"
msgstr ""
"Hai selezionato questo User Id:\n"
" \"%s\"\n"
"\n"
#: g10/keygen.c:660
msgid "NnCcEeOoQq"
msgstr "NnCcEeOoQq"
#: g10/keygen.c:670
msgid "Change (N)ame, (C)omment, (E)mail or (O)kay/(Q)uit? "
msgstr "Modifica (N)ome, (C)ommento, (E)mail oppure (O)kay/(Q)uit? "
#: g10/keygen.c:722
msgid ""
"You need a Passphrase to protect your secret key.\n"
"\n"
msgstr ""
"Ti serve una passphrase per proteggere la tua chiave segreta.\n"
"\n"
#: g10/keyedit.c:389 g10/keygen.c:730
msgid "passphrase not correctly repeated; try again.\n"
msgstr "passphrase non ripetuta correttamente; riprova.\n"
#: g10/keygen.c:736
msgid ""
"You don't want a passphrase - this is probably a *bad* idea!\n"
"I will do it anyway. You can change your passphrase at any time,\n"
"using this program with the option \"--edit-key\".\n"
"\n"
msgstr ""
"Non hai specificato una passphrase - questa è probabilmente una *cattiva*\n"
"idea! Lo farò io comunque. Puoi cambiarla in ogni momento, usando questo\n"
"programma con l'opzione \"--edit-key\".\n"
"\n"
#: g10/keygen.c:757
msgid ""
"We need to generate a lot of random bytes. It is a good idea to perform\n"
"some other action (work in another window, move the mouse, utilize the\n"
"network and the disks) during the prime generation; this gives the random\n"
"number generator a better chance to gain enough entropy.\n"
msgstr ""
"Dobbiamo generare un mucchio di byte casuali. È una buona idea eseguire\n"
"qualche altra azione (lavorare in un'altra finestra, muovere il mouse, "
"usare\n"
"la rete e i dischi) durante la generazione dei numeri primi; questo dà al\n"
"generatore di numeri casuali la possibilità di raccogliere abbastanza\n"
"entropia.\n"
#: g10/keygen.c:827
msgid "Key generation can only be used in interactive mode\n"
msgstr "Una chiave può essere generata solo in modo interattivo\n"
#: g10/keygen.c:835
msgid "DSA keypair will have 1024 bits.\n"
msgstr "La coppia DSA avrà 1024 bit.\n"
#: g10/keygen.c:841
msgid "Key generation cancelled.\n"
msgstr "Generazione della chiave annullata.\n"
#: g10/keygen.c:851
#, c-format
msgid "writing public certificate to '%s'\n"
msgstr "scrittura del certificato pubblico in '%s'\n"
#: g10/keygen.c:852
#, c-format
msgid "writing secret certificate to '%s'\n"
msgstr "scrittura del certificato privato in '%s'\n"
#: g10/keygen.c:929
msgid "public and secret key created and signed.\n"
msgstr "chiavi pubbliche e segrete create e firmate.\n"
#: g10/keygen.c:931
msgid ""
"Note that this key cannot be used for encryption. You may want to use\n"
"the command \"--add-key\" to generate a secondary key for this purpose.\n"
msgstr ""
"Nota che questa chiave non può essere usata per la crittografia. Forse\n"
"vorrai usare il comando \"--add-key\" per generare una chiave secondaria\n"
"per questo scopo.\n"
#: g10/keygen.c:945 g10/keygen.c:1030
#, c-format
msgid "Key generation failed: %s\n"
msgstr "Generazione della chiave fallita: %s\n"
#: g10/keygen.c:1008
msgid "Really create? "
msgstr "Crea davvero? "
#: g10/encode.c:88 g10/openfile.c:81 g10/openfile.c:158 g10/tdbio.c:445
#: g10/tdbio.c:504
#, c-format
msgid "%s: can't open: %s\n"
msgstr "%s: impossibile aprire: %s\n"
#: g10/encode.c:107
#, c-format
msgid "error creating passphrase: %s\n"
msgstr "errore nella creazione della passhprase: %s\n"
#: g10/encode.c:155 g10/encode.c:269
#, fuzzy, c-format
msgid "%s: WARNING: empty file\n"
msgstr "%s: attenzione: file vuoto\n"
#: g10/encode.c:222
#, c-format
msgid "reading from '%s'\n"
msgstr "lettura da '%s'\n"
#: g10/encode.c:397
#, fuzzy, c-format
msgid "%s/%s encrypted for: %s\n"
msgstr "%s crittografato per: %s\n"
#: g10/export.c:114
#, fuzzy, c-format
msgid "%s: user not found: %s\n"
msgstr "%s: utente non trovato\n"
#: g10/export.c:123
#, c-format
msgid "certificate read problem: %s\n"
msgstr ""
#: g10/export.c:132
#, fuzzy, c-format
msgid "key %08lX: not a rfc2440 key - skipped\n"
msgstr "chiave %08lX: chiave segreta senza chiave pubblica - saltata\n"
#: g10/export.c:174
#, fuzzy
msgid "WARNING: nothing exported\n"
msgstr "ATTENZIONE: uso di una chiave non fidata!\n"
#: g10/getkey.c:164
msgid "too many entries in pk cache - disabled\n"
msgstr ""
#: g10/getkey.c:263
msgid "too many entries in unk cache - disabled\n"
msgstr ""
#: g10/getkey.c:989
#, c-format
msgid "using secondary key %08lX instead of primary key %08lX\n"
msgstr "uso la chiave secondaria %08lX invece della chiave primaria %08lX\n"
#: g10/import.c:129 g10/trustdb.c:1166
#, c-format
msgid "can't open file: %s\n"
msgstr "impossibile aprire il file: %s\n"
#: g10/import.c:145
#, c-format
msgid "skipping block of type %d\n"
msgstr "salto un blocco di tipo %d\n"
#: g10/import.c:152 g10/trustdb.c:1425 g10/trustdb.c:1494
#, c-format
msgid "%lu keys so far processed\n"
msgstr "Per ora sono state esaminate %lu chiavi\n"
#: g10/import.c:157 g10/trustdb.c:1242
#, c-format
msgid "read error: %s\n"
msgstr "errore di lettura: %s\n"
#: g10/import.c:159
#, c-format
msgid "Total number processed: %lu\n"
msgstr "Numero totale esaminato: %lu\n"
#: g10/import.c:161
#, c-format
msgid " w/o user IDs: %lu\n"
msgstr "senza user ID: %lu\n"
#: g10/import.c:163
#, c-format
msgid " imported: %lu"
msgstr "importate: %lu"
#: g10/import.c:169
#, c-format
msgid " unchanged: %lu\n"
msgstr "non modificate: %lu\n"
#: g10/import.c:171
#, c-format
msgid " new user IDs: %lu\n"
msgstr "nuovi user ID: %lu\n"
#: g10/import.c:173
#, c-format
msgid " new subkeys: %lu\n"
msgstr "nuove subchiavi: %lu\n"
#: g10/import.c:175
#, c-format
msgid " new signatures: %lu\n"
msgstr "nuove firme: %lu\n"
#: g10/import.c:177
#, c-format
msgid " new key revocations: %lu\n"
msgstr "nuove revoche di chiavi: %lu\n"
#: g10/import.c:179
#, c-format
msgid " secret keys read: %lu\n"
msgstr "chiavi segrete lette: %lu\n"
#: g10/import.c:181
#, c-format
msgid " secret keys imported: %lu\n"
msgstr "chiavi segrete importate %lu\n"
#: g10/import.c:183
#, c-format
msgid " secret keys unchanged: %lu\n"
msgstr "chiavi segrete non cambiate %lu\n"
#: g10/import.c:325 g10/import.c:517
#, c-format
msgid "key %08lX: no user id\n"
msgstr "chiave %08lX: nessun user id\n"
#: g10/import.c:336
#, c-format
msgid "key %08lX: no valid user ids\n"
msgstr "chiave %08lX: nessun user id valido\n"
#: g10/import.c:338
msgid "this may be caused by a missing self-signature\n"
msgstr "questo può essere causato da una autofirma mancante\n"
#: g10/import.c:349 g10/import.c:585
#, c-format
msgid "key %08lX: public key not found: %s\n"
msgstr "chiave %08lX: chiave pubblica non trovata: %s\n"
#: g10/import.c:355
msgid "no default public keyring\n"
msgstr "nessun portachiavi pubblico predefinito\n"
#: g10/import.c:359 g10/openfile.c:105 g10/sign.c:205 g10/sign.c:569
#, c-format
msgid "writing to '%s'\n"
msgstr "scrittura in '%s'\n"
#: g10/import.c:363 g10/import.c:423 g10/import.c:639
#, c-format
msgid "can't lock public keyring: %s\n"
msgstr "impossibile bloccare il portachiavi pubblico: %s\n"
#: g10/import.c:366
#, c-format
msgid "can't write to keyring: %s\n"
msgstr "impossibile scrivere sul portachiavi pubblico: %s\n"
#: g10/import.c:370
#, c-format
msgid "key %08lX: public key imported\n"
msgstr "chiave %08lX: chiave pubblica importata\n"
#: g10/import.c:383
#, c-format
msgid "key %08lX: doesn't match our copy\n"
msgstr "chiave %08lX: non corrisponde alla nostra copia\n"
#: g10/import.c:396 g10/import.c:594
#, c-format
msgid "key %08lX: can't locate original keyblock: %s\n"
msgstr "chiave %08lX: impossibile individuare il keyblock originale: %s\n"
#: g10/import.c:403 g10/import.c:601
#, c-format
msgid "key %08lX: can't read original keyblock: %s\n"
msgstr "chiave %08lX: impossibile leggere il keyblock originale: %s\n"
#: g10/import.c:420 g10/import.c:532 g10/import.c:636
msgid "writing keyblock\n"
msgstr "scrittura del keyblock\n"
#: g10/import.c:426 g10/import.c:642
#, c-format
msgid "can't write keyblock: %s\n"
msgstr "impossibile aprire il keyblock: %s\n"
#: g10/import.c:431
#, c-format
msgid "key %08lX: 1 new user-id\n"
msgstr "chiave %08lX: un nuovo user id\n"
#: g10/import.c:434
#, c-format
msgid "key %08lX: %d new user-ids\n"
msgstr "chiave %08lX: %d nuovi user id\n"
#: g10/import.c:437
#, c-format
msgid "key %08lX: 1 new signature\n"
msgstr "chiave %08lX: una nuova firma\n"
#: g10/import.c:440
#, c-format
msgid "key %08lX: %d new signatures\n"
msgstr "chiave %08lX: %d nuove firme\n"
#: g10/import.c:443
#, c-format
msgid "key %08lX: 1 new subkey\n"
msgstr "chiave %08lX: una nuova subchiave\n"
#: g10/import.c:446
#, c-format
msgid "key %08lX: %d new subkeys\n"
msgstr "chiave %08lX: %d nuove subchiavi\n"
#: g10/import.c:456
#, c-format
msgid "key %08lX: not changed\n"
msgstr "chiave %08lX: non cambiata\n"
#: g10/import.c:535
#, c-format
msgid "can't lock secret keyring: %s\n"
msgstr "impossibile bloccare il portachiavi segreto: %s\n"
#: g10/import.c:538
#, c-format
msgid "can't write keyring: %s\n"
msgstr "impossibile scrivere il portachiavi: %s\n"
#. we are ready
#: g10/import.c:541
#, c-format
msgid "key %08lX: secret key imported\n"
msgstr "chiave %08lX: chiave segreta importata\n"
#. we can't merge secret keys
#: g10/import.c:545
#, c-format
msgid "key %08lX: already in secret keyring\n"
msgstr "chiave %08lX: già nel portachiavi segreto\n"
#: g10/import.c:550
#, c-format
msgid "key %08lX: secret key not found: %s\n"
msgstr "chiave %08lX: chiave segreta non trovata: %s\n"
#: g10/import.c:579
#, c-format
msgid "key %08lX: no public key - can't apply revocation certificate\n"
msgstr ""
"chiave %08lX: manca la chiave pubblica - impossibile applicare il\n"
"certificato di revoca\n"
#: g10/import.c:612
#, c-format
msgid "key %08lX: invalid revocation certificate: %s - rejected\n"
msgstr "chiave %08lX: certificato di revoca non valido: %s - rifiutato\n"
#: g10/import.c:646
#, c-format
msgid "key %08lX: revocation certificate imported\n"
msgstr "chiave %08lX: certificato di revoca importato\n"
#: g10/import.c:677
#, c-format
msgid "key %08lX: no user-id for signature\n"
msgstr "chiave %08lX: nessun user id per la firma\n"
#: g10/import.c:684
#, c-format
msgid "key %08lX: unsupported public key algorithm\n"
msgstr "chiave %08lX: algoritmo a chiave pubblica non gestito\n"
#: g10/import.c:685
#, c-format
msgid "key %08lX: invalid self-signature\n"
msgstr "chiave %08lX: autofirma non valida\n"
#: g10/import.c:714
#, c-format
msgid "key %08lX: skipped userid '"
msgstr "chiave %08lX: saltato l'user id '"
#: g10/import.c:737
#, c-format
msgid "key %08lX: revocation certificate at wrong place - skipped\n"
msgstr "chiave %08lX: certificato di revoca nel posto sbagliato - saltato\n"
#: g10/import.c:745
#, c-format
msgid "key %08lX: invalid revocation certificate: %s - skipped\n"
msgstr "chiave %08lX: certificato di revoca non valido: %s - saltato\n"
#: g10/import.c:804
#, c-format
msgid "key %08lX: revocation certificate added\n"
msgstr "chiave %08lX: certificato di revoca aggiunto\n"
#: g10/import.c:918 g10/import.c:973
#, c-format
msgid "key %08lX: our copy has no self-signature\n"
msgstr "chiave %08lX: la nostra copia non ha autofirma\n"
#: g10/keyedit.c:81
#, c-format
msgid "%s: user not found\n"
msgstr "%s: utente non trovato\n"
#: g10/keyedit.c:164
msgid "[self-signature]"
msgstr "[autofirma]"
#: g10/keyedit.c:182
msgid "1 bad signature\n"
msgstr "una firma non corretta\n"
#: g10/keyedit.c:184
#, c-format
msgid "%d bad signatures\n"
msgstr "%d firme non corrette\n"
#: g10/keyedit.c:186
msgid "1 signature not checked due to a missing key\n"
msgstr "1 firma non controllata per mancanza della chiave\n"
#: g10/keyedit.c:188
#, c-format
msgid "%d signatures not checked due to missing keys\n"
msgstr "%d firme non controllate per mancanza delle chiavi\n"
#: g10/keyedit.c:190
msgid "1 signature not checked due to an error\n"
msgstr "1 firma non controllata a causa di un errore\n"
#: g10/keyedit.c:192
#, c-format
msgid "%d signatures not checked due to errors\n"
msgstr "%d firme non controllate a causa di errori\n"
#: g10/keyedit.c:194
msgid "1 user id without valid self-signature detected\n"
msgstr "Trovato 1 user id senza autofirma valida\n"
#: g10/keyedit.c:196
#, c-format
msgid "%d user ids without valid self-signatures detected\n"
msgstr "Trovati %d user id senza autofirme valide\n"
#: g10/keyedit.c:258
#, c-format
msgid "Already signed by key %08lX\n"
msgstr "Già firmato dalla chiave %08lX\n"
#: g10/keyedit.c:266
#, c-format
msgid "Nothing to sign with key %08lX\n"
msgstr "Niente da firmare con la chiave %08lX\n"
#: g10/keyedit.c:275
msgid ""
"Are you really sure that you want to sign this key\n"
"with your key: \""
msgstr ""
"Sei davvero sicuro di volere firmare questa chiave\n"
"con la tua chiave: \""
#: g10/keyedit.c:282
msgid "Really sign? "
msgstr "Firmo davvero? "
#: g10/keyedit.c:303 g10/sign.c:65
#, c-format
msgid "signing failed: %s\n"
msgstr "firma fallita: %s\n"
#: g10/keyedit.c:356
msgid "This key is not protected.\n"
msgstr "Questa chiave non è protetta.\n"
#: g10/keyedit.c:359
msgid "Key is protected.\n"
msgstr "La chiave è protetta.\n"
#: g10/keyedit.c:376
#, c-format
msgid "Can't edit this key: %s\n"
msgstr "Impossibile modificare questa chiave: %s\n"
#: g10/keyedit.c:381
msgid ""
"Enter the new passphrase for this secret key.\n"
"\n"
msgstr ""
"Inserisci la nuova passphrase per questa chiave segreta.\n"
"\n"
#: g10/keyedit.c:393
msgid ""
"You don't want a passphrase - this is probably a *bad* idea!\n"
"\n"
msgstr ""
"Non vuoi una passphrase - questa è probabilmente una *cattiva* idea!\n"
"\n"
#: g10/keyedit.c:396
msgid "Do you really want to do this? "
msgstr "Vuoi veramente farlo?"
#: g10/keyedit.c:455
msgid "moving a key signature to the correct place\n"
msgstr ""
#: g10/keyedit.c:490
msgid "quit"
msgstr "quit"
#: g10/keyedit.c:490
msgid "quit this menu"
msgstr "abbandona questo menù"
#: g10/keyedit.c:491
msgid "q"
msgstr "q"
#: g10/keyedit.c:492
msgid "save"
msgstr "save"
#: g10/keyedit.c:492
msgid "save and quit"
msgstr "salva ed esci"
#: g10/keyedit.c:493
msgid "help"
msgstr "help"
#: g10/keyedit.c:493
msgid "show this help"
msgstr "mostra questo aiuto"
#: g10/keyedit.c:495
msgid "fpr"
msgstr "fpr"
#: g10/keyedit.c:495
msgid "show fingerprint"
msgstr "mostra le impronte digitali"
#: g10/keyedit.c:496
msgid "list"
msgstr "list"
#: g10/keyedit.c:496
msgid "list key and user ids"
msgstr "elenca le chiavi e gli user id"
#: g10/keyedit.c:497
msgid "l"
msgstr "l"
#: g10/keyedit.c:498
msgid "uid"
msgstr "uid"
#: g10/keyedit.c:498
msgid "select user id N"
msgstr "scegli l'user id N"
#: g10/keyedit.c:499
msgid "key"
msgstr "key"
#: g10/keyedit.c:499
msgid "select secondary key N"
msgstr "scegli la chiave secondaria N"
#: g10/keyedit.c:500
msgid "check"
msgstr "check"
#: g10/keyedit.c:500
msgid "list signatures"
msgstr "elenca le firme"
#: g10/keyedit.c:501
msgid "c"
msgstr "c"
#: g10/keyedit.c:502
msgid "sign"
msgstr "sign"
#: g10/keyedit.c:502
msgid "sign the key"
msgstr "firma la chiave"
#: g10/keyedit.c:503
msgid "s"
msgstr "s"
#: g10/keyedit.c:504
msgid "debug"
msgstr "debug"
#: g10/keyedit.c:505
msgid "adduid"
msgstr "adduid"
#: g10/keyedit.c:505
msgid "add a user id"
msgstr "aggiungi un user id"
#: g10/keyedit.c:506
msgid "deluid"
msgstr "deluid"
#: g10/keyedit.c:506
msgid "delete user id"
msgstr "cancella un user id"
#: g10/keyedit.c:507
msgid "addkey"
msgstr "addkey"
#: g10/keyedit.c:507
msgid "add a secondary key"
msgstr "aggiungi una chiave secondaria"
#: g10/keyedit.c:508
msgid "delkey"
msgstr "delkey"
#: g10/keyedit.c:508
msgid "delete a secondary key"
msgstr "cancella una chiave secondaria"
#: g10/keyedit.c:509
msgid "expire"
msgstr "expire"
#: g10/keyedit.c:509
msgid "change the expire date"
msgstr "cambia la data di scadenza"
#: g10/keyedit.c:510
msgid "toggle"
msgstr "toggle"
#: g10/keyedit.c:510
msgid "toggle between secret and public key listing"
msgstr "cambia tra visualizzare la chiave segreta e la chiave pubblica"
#: g10/keyedit.c:512
msgid "t"
msgstr "t"
#: g10/keyedit.c:513
msgid "pref"
msgstr "pref"
#: g10/keyedit.c:513
msgid "list preferences"
msgstr "elenca le impostazioni"
#: g10/keyedit.c:514
msgid "passwd"
msgstr "passwd"
#: g10/keyedit.c:514
msgid "change the passphrase"
msgstr "cambia la passphrase"
#: g10/keyedit.c:515
msgid "trust"
msgstr "trust"
#: g10/keyedit.c:515
msgid "change the ownertrust"
msgstr "cambia il valore di fiducia"
#: g10/keyedit.c:534
msgid "can't do that in batchmode\n"
msgstr "impossibile fare questo in batch mode\n"
#. check that they match
#. FIXME: check that they both match
#: g10/keyedit.c:561
msgid "Secret key is available.\n"
msgstr "È disponibile una chiave segreta.\n"
#: g10/keyedit.c:590
msgid "Command> "
msgstr "Comando> "
#: g10/keyedit.c:617
msgid "Need the secret key to do this.\n"
msgstr "Per fare questo serve la chiave segreta.\n"
#: g10/keyedit.c:639
msgid "Save changes? "
msgstr "Salvo i cambiamenti? "
#: g10/keyedit.c:642
msgid "Quit without saving? "
msgstr "Esco senza salvare? "
#: g10/keyedit.c:652
#, c-format
msgid "update failed: %s\n"
msgstr "aggiornamento fallito: %s\n"
#: g10/keyedit.c:659
#, c-format
msgid "update secret failed: %s\n"
msgstr "aggiornamento della chiave segreta fallito: %s\n"
#: g10/keyedit.c:666
msgid "Key not changed so no update needed.\n"
msgstr "La chiave non è cambiata quindi non sono necessari aggiornamenti.\n"
#: g10/keyedit.c:669 g10/keyedit.c:727
#, c-format
msgid "update of trust db failed: %s\n"
msgstr "aggiornamento del trustdb fallito: %s\n"
#: g10/keyedit.c:701
msgid "Really sign all user ids? "
msgstr "Firmo davvero tutti gli user id? "
#: g10/keyedit.c:702
msgid "Hint: Select the user ids to sign\n"
msgstr "Suggerimento: seleziona gli user id da firmare\n"
#: g10/keyedit.c:738
msgid "You must select at least one user id.\n"
msgstr "Devi selezionare almeno un user id.\n"
#: g10/keyedit.c:740
msgid "You can't delete the last user id!\n"
msgstr "Non puoi cancellare l'ultimo user id!\n"
#: g10/keyedit.c:743
msgid "Really remove all selected user ids? "
msgstr "Tolgo davvero tutti gli user id selezionati? "
#: g10/keyedit.c:744
msgid "Really remove this user id? "
msgstr "Tolgo davvero questo user id? "
#: g10/keyedit.c:767
msgid "You must select at least one key.\n"
msgstr "Devi selezionare almeno una chiave.\n"
#: g10/keyedit.c:771
msgid "Do you really want to delete the selected keys? "
msgstr "Vuoi davvero cancellare le chiavi selezionate? "
#: g10/keyedit.c:772
msgid "Do you really want to delete this key? "
msgstr "Vuoi davvero cancellare questa chiave? "
#: g10/keyedit.c:819
msgid "Invalid command (try \"help\")\n"
msgstr "Comando non valido (prova \"help\")\n"
#: g10/keyedit.c:1197
msgid "Please remove selections from the secret keys.\n"
msgstr "Togli le selezioni dalle chiavi segrete.\n"
#: g10/keyedit.c:1203
msgid "Please select at most one secondary key.\n"
msgstr "Seleziona al massimo una chiave secondaria.\n"
#: g10/keyedit.c:1207
msgid "Changing exiration time for a secondary key.\n"
msgstr "Modifico il tempo di scadenza per una chiave secondaria.\n"
#: g10/keyedit.c:1209
msgid "Changing exiration time for the primary key.\n"
msgstr "Modifico il tempo di scadenza per la chiave primaria.\n"
#: g10/keyedit.c:1250
msgid "You can't change the expiration date of a v3 key\n"
msgstr ""
#: g10/keyedit.c:1266
msgid "No corresponding signature in secret ring\n"
msgstr "Manca la firma corrispondente nel portachiavi segreto\n"
#: g10/keyedit.c:1326
#, c-format
msgid "No user id with index %d\n"
msgstr "Nessun user id con l'indice %d\n"
#: g10/keyedit.c:1371
#, c-format
msgid "No secondary key with index %d\n"
msgstr "Nessuna chiave secondaria con l'indice %d\n"
#: g10/mainproc.c:198
#, fuzzy
msgid "public key encrypted data: Good DEK\n"
msgstr "Decifratura della chiave pubblica fallita: %s\n"
#: g10/mainproc.c:201
#, c-format
msgid "public key decryption failed: %s\n"
msgstr "Decifratura della chiave pubblica fallita: %s\n"
#: g10/mainproc.c:228
#, fuzzy
msgid "decryption okay\n"
msgstr "decifratura fallita: %s\n"
#: g10/mainproc.c:231
#, c-format
msgid "decryption failed: %s\n"
msgstr "decifratura fallita: %s\n"
#: g10/mainproc.c:248
#, fuzzy
msgid "NOTE: sender requested \"for-your-eyes-only\"\n"
msgstr "nota: il mittente ha richiesto \"solo-per-i-tuoi-occhi\"\n"
#: g10/mainproc.c:250
#, c-format
msgid "original file name='%.*s'\n"
msgstr ""
#: g10/mainproc.c:833
msgid "signature verification suppressed\n"
msgstr ""
#: g10/mainproc.c:839
#, c-format
msgid "Signature made %.*s using %s key ID %08lX\n"
msgstr "Firma fatta %.*s usando %s key ID %08lX\n"
#: g10/mainproc.c:847
msgid "BAD signature from \""
msgstr "Firma NON corretta da \""
#: g10/mainproc.c:848
msgid "Good signature from \""
msgstr "Buona firma da \""
#: g10/mainproc.c:861
#, c-format
msgid "Can't check signature: %s\n"
msgstr "Impossibile controllare la firma: %s\n"
#: g10/mainproc.c:934
msgid "old style (PGP 2.x) signature\n"
msgstr ""
#: g10/mainproc.c:939
msgid "invalid root packet detected in proc_tree()\n"
msgstr ""
#: g10/misc.c:88
#, fuzzy, c-format
msgid "can't disable core dumps: %s\n"
msgstr "impossibile aprire '%s': %s\n"
#: g10/misc.c:90
msgid "WARNING: Program may create a core file!\n"
msgstr ""
#: g10/misc.c:198
msgid "Experimental algorithms should not be used!\n"
msgstr ""
#: g10/misc.c:212
msgid ""
"RSA keys are deprecated; please consider creating a new key and use this key "
"in the future\n"
msgstr ""
"L'uso di chiavi RSA è deprecato; per favore in futuro considera di creare e\n"
"usare una nuova chiave.\n"
#: g10/misc.c:233
msgid "This cipher algorithm is depreciated; please use a more standard one!\n"
msgstr ""
#: g10/parse-packet.c:109
#, fuzzy, c-format
msgid "can't handle public key algorithm %d\n"
msgstr "impossibile bloccare il portachiavi pubblico: %s\n"
#: g10/passphrase.c:141
msgid ""
"\n"
"You need a passphrase to unlock the secret key for\n"
"user: \""
msgstr ""
"\n"
"Ti serve una passphrase per sbloccare la chiave segreta\n"
"dell'utente: \""
#: g10/passphrase.c:150
#, c-format
msgid "(%u-bit %s key, ID %08lX, created %s)\n"
msgstr "(chiave %2$s di %1$u-bit, ID %3$08lX, creata il %4$s)\n"
#: g10/passphrase.c:174
#, fuzzy
msgid "Enter passphrase: "
msgstr "Inserisci la passphrase: "
#: g10/passphrase.c:178
#, fuzzy
msgid "Repeat passphrase: "
msgstr "Ripeti la passphrase: "
#: g10/plaintext.c:102
msgid "data not saved; use option \"--output\" to save it\n"
msgstr ""
"i dati non sono stati salvati; usa l'opzione \"--output\" per salvarli\n"
#: g10/plaintext.c:215
msgid "Please enter name of data file: "
msgstr "Inserisci il nome del file di dati: "
#: g10/plaintext.c:236
msgid "reading stdin ...\n"
msgstr ""
#: g10/plaintext.c:299
#, c-format
msgid "can't open signed data '%s'\n"
msgstr "impossibile aprire i dati firmati '%s'\n"
#: g10/pubkey-enc.c:78
#, c-format
msgid "anonymous receiver; trying secret key %08lX ...\n"
msgstr "ricevente anonimo; provo la chiave segreta %08lX ...\n"
#: g10/pubkey-enc.c:84
msgid "okay, we are the anonymous receiver.\n"
msgstr "Bene, siamo il ricevente anonimo.\n"
#: g10/pubkey-enc.c:136
#, fuzzy
msgid "old encoding of the DEK is not supported\n"
msgstr "l'algoritmo di protezione %d non è gestito\n"
#: g10/pubkey-enc.c:183
#, fuzzy, c-format
msgid "NOTE: cipher algorithm %d not found in preferences\n"
msgstr "nota: algoritmo di cifratura %d non trovato nelle impostazioni\n"
#: g10/seckey-cert.c:56
#, c-format
msgid "protection algorithm %d is not supported\n"
msgstr "l'algoritmo di protezione %d non è gestito\n"
#: g10/seckey-cert.c:169
msgid "Invalid passphrase; please try again ...\n"
msgstr "Passphrase non valida; riprova...\n"
#: g10/seckey-cert.c:216
#, fuzzy
msgid "WARNING: Weak key detected - please change passphrase again.\n"
msgstr ""
"Attenzione: individuata una chiave debole - per favore cambia ancora la\n"
"passphrase.\n"
#: g10/sig-check.c:155
msgid ""
"this is a PGP generated ElGamal key which is NOT secure for signatures!\n"
msgstr ""
"questa è una chiave ElGamal generata da PGP che NON è sicura per le firme!\n"
#: g10/sig-check.c:165
msgid "public key created in future (time warp or clock problem)\n"
msgstr ""
"chiave pubblica creata nel futuro (salto nel tempo o problema con\n"
"l'orologio)\n"
#: g10/sig-check.c:170
#, fuzzy, c-format
msgid "NOTE: signature key expired %s\n"
msgstr "attenzione: firma della chiave scaduta il %s\n"
#: g10/sign.c:69
#, fuzzy, c-format
msgid "%s signature from: %s\n"
msgstr "Firma NON corretta da \""
#: g10/sign.c:200 g10/sign.c:564
#, fuzzy, c-format
msgid "can't create %s: %s\n"
msgstr "%s: impossibile creare: %s\n"
#: g10/sign.c:296
#, fuzzy
msgid "signing:"
msgstr "sign"
#: g10/sign.c:336
#, fuzzy, c-format
msgid "WARNING: '%s' is an empty file\n"
msgstr "%s: attenzione: file vuoto\n"
#: g10/tdbio.c:116 g10/tdbio.c:1413
#, fuzzy, c-format
msgid "trustdb rec %lu: lseek failed: %s\n"
msgstr "aggiornamento della chiave segreta fallito: %s\n"
#: g10/tdbio.c:122 g10/tdbio.c:1420
#, c-format
msgid "trustdb rec %lu: write failed (n=%d): %s\n"
msgstr ""
#: g10/tdbio.c:232
msgid "trustdb transaction to large\n"
msgstr ""
#: g10/tdbio.c:402
#, fuzzy, c-format
msgid "%s: can't access: %s\n"
msgstr "%s: impossibile creare: %s\n"
#: g10/ringedit.c:273 g10/tdbio.c:422
#, fuzzy, c-format
msgid "%s: can't create directory: %s\n"
msgstr "%s: impossibile creare: %s\n"
#: g10/ringedit.c:279 g10/tdbio.c:425
#, fuzzy, c-format
msgid "%s: directory created\n"
msgstr "%s: impossibile creare: %s\n"
#: g10/tdbio.c:429
#, c-format
msgid "%s: directory does not exist!\n"
msgstr ""
#: g10/openfile.c:101 g10/openfile.c:165 g10/ringedit.c:1256 g10/tdbio.c:435
#, c-format
msgid "%s: can't create: %s\n"
msgstr "%s: impossibile creare: %s\n"
#: g10/tdbio.c:459
#, c-format
msgid "%s: failed to create version record: %s"
msgstr ""
#: g10/tdbio.c:463
#, c-format
msgid "%s: invalid trust-db created\n"
msgstr ""
#: g10/tdbio.c:465
#, fuzzy, c-format
msgid "%s: trust-db created\n"
msgstr "%s: impossibile creare: %s\n"
#: g10/tdbio.c:506
#, c-format
msgid "%s: invalid trust-db\n"
msgstr ""
#: g10/tdbio.c:540
#, fuzzy, c-format
msgid "%s: failed to create hashtable: %s\n"
msgstr "%s: impossibile creare: %s\n"
#: g10/tdbio.c:548
#, fuzzy, c-format
msgid "%s: error updating version record: %s\n"
msgstr "%s: errore nel controllare la chiave: %s\n"
#: g10/tdbio.c:564 g10/tdbio.c:603 g10/tdbio.c:628 g10/tdbio.c:1346
#: g10/tdbio.c:1373
#, fuzzy, c-format
msgid "%s: error reading version record: %s\n"
msgstr "%s: errore nel controllare la chiave: %s\n"
#: g10/tdbio.c:577
#, fuzzy, c-format
msgid "%s: error writing version record: %s\n"
msgstr "%s: errore nel controllare la chiave: %s\n"
#: g10/tdbio.c:1053
#, fuzzy, c-format
msgid "trustdb: lseek failed: %s\n"
msgstr "aggiornamento della chiave segreta fallito: %s\n"
#: g10/tdbio.c:1061
#, fuzzy, c-format
msgid "trustdb: read failed (n=%d): %s\n"
msgstr "aggiornamento del trustdb fallito: %s\n"
#: g10/tdbio.c:1082
#, fuzzy, c-format
msgid "%s: not a trustdb file\n"
msgstr "aggiornamento del trustdb fallito: %s\n"
#: g10/tdbio.c:1098
#, c-format
msgid "%s: version record with recnum %lu\n"
msgstr ""
#: g10/tdbio.c:1103
#, fuzzy, c-format
msgid "%s: invalid file version %d\n"
msgstr "header della firma in chiaro non valido\n"
#: g10/tdbio.c:1379
#, fuzzy, c-format
msgid "%s: error reading free record: %s\n"
msgstr "%s: errore nel controllare la chiave: %s\n"
#: g10/tdbio.c:1387
#, fuzzy, c-format
msgid "%s: error writing dir record: %s\n"
msgstr "%s: errore nel controllare la chiave: %s\n"
#: g10/tdbio.c:1397
#, c-format
msgid "%s: failed to zero a record: %s\n"
msgstr ""
#: g10/tdbio.c:1427
#, c-format
msgid "%s: failed to append a record: %s\n"
msgstr ""
#: g10/trustdb.c:134
msgid "The trust DB is corrupted; please run \"gpgm --fix-trust-db\".\n"
msgstr "Il trustdb è rovinato; per favore esegui \"gpgm --fix-trust-db\".\n"
#: g10/trustdb.c:147
#, c-format
msgid "trust record %lu, req type %d: read failed: %s\n"
msgstr ""
#: g10/trustdb.c:162
#, c-format
msgid "trust record %lu, type %d: write failed: %s\n"
msgstr ""
#: g10/trustdb.c:176
#, fuzzy, c-format
msgid "trust record %lu: delete failed: %s\n"
msgstr "aggiornamento della chiave segreta fallito: %s\n"
#: g10/trustdb.c:190
#, fuzzy, c-format
msgid "trust db: sync failed: %s\n"
msgstr "aggiornamento del trustdb fallito: %s\n"
#: g10/trustdb.c:319
#, c-format
msgid "error reading dir record for LID %lu: %s\n"
msgstr ""
#: g10/trustdb.c:326
#, c-format
msgid "lid %lu: expected dir record, got type %d\n"
msgstr ""
#: g10/trustdb.c:331
#, c-format
msgid "no primary key for LID %lu\n"
msgstr ""
#: g10/trustdb.c:336
#, fuzzy, c-format
msgid "error reading primary key for LID %lu: %s\n"
msgstr "errore nella creazione della passhprase: %s\n"
#: g10/trustdb.c:412
#, c-format
msgid "chained sigrec %lu has a wrong owner\n"
msgstr "la chained sigrec %lu ha il proprietario sbagliato\n"
#: g10/trustdb.c:455
#, fuzzy, c-format
msgid "'%s' is not a valid long keyID\n"
msgstr "Carattere non valido nel commento\n"
#: g10/trustdb.c:490
#, fuzzy, c-format
msgid "key %08lX: no public key for trusted key - skipped\n"
msgstr "chiave %08lX: chiave segreta senza chiave pubblica - saltata\n"
#: g10/trustdb.c:499 g10/trustdb.c:557
#, c-format
msgid "key %08lX: can't put it into the trustdb\n"
msgstr "chiave %08lX: impossibile metterla nel trustdb\n"
#: g10/trustdb.c:504 g10/trustdb.c:563
#, c-format
msgid "key %08lX: query record failed\n"
msgstr "chiave %08lX: richiesta del record fallita\n"
#: g10/trustdb.c:509 g10/trustdb.c:572
#, fuzzy, c-format
msgid "key %08lX: already in trusted key table\n"
msgstr "chiave %08lX: già nella tabella delle chiavi segrete\n"
#: g10/trustdb.c:512 g10/trustdb.c:575
#, fuzzy, c-format
msgid "key %08lX: accepted as trusted key.\n"
msgstr "chiave %08lX: accettata come chiave segreta\n"
#: g10/trustdb.c:528
#, fuzzy, c-format
msgid "NOTE: secret key %08lX is NOT protected.\n"
msgstr "Questa chiave non è protetta.\n"
#: g10/trustdb.c:540
#, c-format
msgid "key %08lX: secret key without public key - skipped\n"
msgstr "chiave %08lX: chiave segreta senza chiave pubblica - saltata\n"
#: g10/trustdb.c:547
#, c-format
msgid "key %08lX: secret and public key don't match\n"
msgstr "chiave %08lX: le chiavi segreta e pubblica non corrispondono\n"
#: g10/trustdb.c:583
#, fuzzy, c-format
msgid "enumerate secret keys failed: %s\n"
msgstr "enum_secret_keys fallito: %s\n"
#: g10/trustdb.c:766
#, fuzzy, c-format
msgid "lid %lu: read dir record failed: %s\n"
msgstr "chiave %08lX: inserimento del record della fiducia fallito: %s\n"
#: g10/trustdb.c:775
#, fuzzy, c-format
msgid "lid %lu: read key record failed: %s\n"
msgstr "chiave %08lX: inserimento del record della fiducia fallito: %s\n"
#: g10/trustdb.c:785
#, fuzzy, c-format
msgid "lid %lu: read uid record failed: %s\n"
msgstr "chiave %08lX: inserimento del record della fiducia fallito: %s\n"
#: g10/trustdb.c:794
#, fuzzy, c-format
msgid "lid %lu: read pref record failed: %s\n"
msgstr "chiave %08lX: inserimento del record della fiducia fallito: %s\n"
#: g10/trustdb.c:804
#, fuzzy, c-format
msgid "lid %lu: read sig record failed: %s\n"
msgstr "chiave %08lX: inserimento del record della fiducia fallito: %s\n"
#: g10/trustdb.c:999
msgid "Ooops, no keys\n"
msgstr ""
#: g10/trustdb.c:1003
#, fuzzy
msgid "Ooops, no user ids\n"
msgstr "elenca le chiavi e gli user id"
#: g10/trustdb.c:1074 g10/trustdb.c:1092
#, c-format
msgid "user '%s' read problem: %s\n"
msgstr ""
#: g10/trustdb.c:1077 g10/trustdb.c:1095
#, c-format
msgid "user '%s' list problem: %s\n"
msgstr ""
#: g10/trustdb.c:1085 g10/trustdb.c:1300
#, fuzzy, c-format
msgid "user '%s' not found: %s\n"
msgstr "%s: utente non trovato\n"
#: g10/trustdb.c:1087 g10/trustdb.c:1302
#, c-format
msgid "problem finding '%s' in trustdb: %s\n"
msgstr ""
#: g10/trustdb.c:1090
#, c-format
msgid "user '%s' not in trustdb\n"
msgstr ""
#: g10/trustdb.c:1125
#, c-format
msgid ""
"# List of assigned trustvalues, created %s\n"
"# (Use \"gpgm --import-ownertrust\" to restore them)\n"
msgstr ""
#: g10/trustdb.c:1131
msgid "directory record w/o primary key\n"
msgstr ""
#: g10/trustdb.c:1138
#, fuzzy, c-format
msgid "error reading key record: %s\n"
msgstr "%s: errore nel controllare la chiave: %s\n"
#: g10/trustdb.c:1178
-msgid "line to long\n"
+msgid "line too long\n"
msgstr ""
#: g10/trustdb.c:1186
msgid "error: missing colon\n"
msgstr ""
#: g10/trustdb.c:1191
#, fuzzy
msgid "error: invalid fingerprint\n"
msgstr "errore nella riga della coda\n"
#: g10/trustdb.c:1195
#, fuzzy
msgid "error: no ownertrust value\n"
msgstr "esporta i valori di fiducia"
#: g10/trustdb.c:1209
#, c-format
msgid "LID %lu: changing trust from %u to %u\n"
msgstr ""
#: g10/trustdb.c:1212
#, c-format
msgid "LID %lu: setting trust to %u\n"
msgstr ""
#: g10/trustdb.c:1220
msgid "key not in trustdb, searching ring.\n"
msgstr ""
#: g10/trustdb.c:1223
#, fuzzy, c-format
msgid "key not in ring: %s\n"
msgstr "impossibile scrivere il portachiavi: %s\n"
#: g10/trustdb.c:1227
msgid "Oops: key is now in trustdb???\n"
msgstr ""
#. update the ownertrust
#: g10/trustdb.c:1232
#, fuzzy, c-format
msgid "insert trust record failed: %s\n"
msgstr "chiave %08lX: inserimento del record della fiducia fallito: %s\n"
#. error
#: g10/trustdb.c:1238
#, fuzzy, c-format
msgid "error finding dir record: %s\n"
msgstr "rimozione dell'armatura fallita: %s\n"
#: g10/trustdb.c:1305
#, c-format
msgid "user '%s' not in trustdb - inserting\n"
msgstr ""
#: g10/trustdb.c:1308
#, fuzzy, c-format
msgid "failed to put '%s' into trustdb: %s\n"
msgstr "inizializzazione del trustdb fallita: %s\n"
#: g10/trustdb.c:1355
#, c-format
msgid "%s: keyblock read problem: %s\n"
msgstr ""
#: g10/trustdb.c:1369
#, fuzzy, c-format
msgid "%s: update failed: %s\n"
msgstr "aggiornamento fallito: %s\n"
#: g10/trustdb.c:1372
#, fuzzy, c-format
msgid "%s: updated\n"
msgstr "\\t%lu chiavi aggiornate\n"
#: g10/trustdb.c:1374
#, c-format
msgid "%s: okay\n"
msgstr ""
#: g10/trustdb.c:1389
#, c-format
msgid "lid %lu: dir record w/o key - skipped\n"
msgstr ""
#: g10/trustdb.c:1402
#, fuzzy, c-format
msgid "lid %lu: keyblock not found: %s\n"
msgstr "chiave %08lX: chiave pubblica non trovata: %s\n"
#: g10/trustdb.c:1411 g10/trustdb.c:1480
#, fuzzy, c-format
msgid "lid %lu: update failed: %s\n"
msgstr "aggiornamento fallito: %s\n"
#: g10/trustdb.c:1417 g10/trustdb.c:1486
#, fuzzy, c-format
msgid "lid %lu: updated\n"
msgstr "\\t%lu chiavi aggiornate\n"
#: g10/trustdb.c:1421 g10/trustdb.c:1490
#, fuzzy, c-format
msgid "lid %lu: okay\n"
msgstr "lid %lu: manca la chiave primaria\n"
#: g10/trustdb.c:1428 g10/trustdb.c:1496
#, c-format
msgid "%lu keys processed\n"
msgstr "%lu chiavi esaminate\n"
#: g10/trustdb.c:1430
#, c-format
msgid "\t%lu keys skipped\n"
msgstr "\\t%lu chiavi saltate\n"
#: g10/trustdb.c:1432 g10/trustdb.c:1498
#, c-format
msgid "\t%lu keys with errors\n"
msgstr "\\t%lu chiavi con errori\n"
#: g10/trustdb.c:1434 g10/trustdb.c:1500
#, c-format
msgid "\t%lu keys updated\n"
msgstr "\\t%lu chiavi aggiornate\n"
#: g10/trustdb.c:1464
#, fuzzy, c-format
msgid "lid ?: insert failed: %s\n"
msgstr "aggiornamento della chiave segreta fallito: %s\n"
#: g10/trustdb.c:1469
#, fuzzy, c-format
msgid "lid %lu: insert failed: %s\n"
msgstr "aggiornamento della chiave segreta fallito: %s\n"
#: g10/trustdb.c:1475
#, fuzzy, c-format
msgid "lid %lu: inserted\n"
msgstr "\\t%lu chiavi inserite\n"
#: g10/trustdb.c:1502
#, c-format
msgid "\t%lu keys inserted\n"
msgstr "\\t%lu chiavi inserite\n"
#: g10/trustdb.c:1505
#, fuzzy, c-format
msgid "enumerate keyblocks failed: %s\n"
msgstr "enum_secret_keys fallito: %s\n"
#: g10/trustdb.c:1550
#, fuzzy, c-format
msgid "check_trust: search dir record failed: %s\n"
msgstr "chiave %08lX: inserimento del record della fiducia fallito: %s\n"
#: g10/trustdb.c:1557
#, c-format
msgid "key %08lX: insert trust record failed: %s\n"
msgstr "chiave %08lX: inserimento del record della fiducia fallito: %s\n"
#: g10/trustdb.c:1561
#, c-format
msgid "key %08lX.%lu: inserted into trustdb\n"
msgstr "chiave %08lX.%lu: inserita nel trustdb\n"
#: g10/trustdb.c:1569
#, c-format
msgid "key %08lX.%lu: created in future (time warp or clock problem)\n"
msgstr ""
"chiave %08lX.%lu: creata nel futuro (salto nel tempo o problema\n"
"con l'orologio)\n"
#: g10/trustdb.c:1576
#, c-format
msgid "key %08lX.%lu: expired at %s\n"
msgstr "chiave %08lX.%lu: scaduta il %s\n"
#: g10/trustdb.c:1584
#, c-format
msgid "key %08lX.%lu: trust check failed: %s\n"
msgstr "chiave %08lX.%lu: controllo della fiducia fallito: %s\n"
#: g10/trustdb.c:1753 g10/trustdb.c:1782 g10/trustdb.c:2521
msgid "WARNING: can't yet handle long pref records\n"
msgstr ""
#: g10/trustdb.c:1804
#, fuzzy, c-format
msgid "get_dir_record: search_record failed: %s\n"
msgstr "aggiornamento della chiave segreta fallito: %s\n"
#: g10/trustdb.c:1867
#, fuzzy, c-format
msgid "NOTE: sig rec %lu[%d] in hintlist of %lu but marked as checked\n"
msgstr ""
"nota: rec di %lu[%d] nella hintlist di %lu ma marcato come verificato\n"
#: g10/trustdb.c:1871
#, fuzzy, c-format
msgid "NOTE: sig rec %lu[%d] in hintlist of %lu but not marked\n"
msgstr "nota: rec di %lu[%d] nella hintlist di %lu ma non marcato\n"
#. we need the dir record
#: g10/trustdb.c:1878
#, c-format
msgid "sig rec %lu[%d] in hintlist of %lu does not point to a dir record\n"
msgstr "Il rec di %lu[%d] nella hintlist di %lu non punta a un record dir\n"
#: g10/trustdb.c:1884
#, c-format
msgid "lid %lu: no primary key\n"
msgstr "lid %lu: manca la chiave primaria\n"
#: g10/trustdb.c:1917
#, c-format
msgid "lid %lu: user id not found in keyblock\n"
msgstr "lid %lu: user id non trovato nel keyblock\n"
#: g10/trustdb.c:1921
#, c-format
msgid "lid %lu: user id without signature\n"
msgstr "chiave %08lX: user id senza firma\n"
#: g10/trustdb.c:1928
#, c-format
msgid "lid %lu: self-signature in hintlist\n"
msgstr "lid %lu: autofirma nella hintlist\n"
#: g10/trustdb.c:1939 g10/trustdb.c:2658 g10/trustdb.c:2742
msgid "Valid certificate revocation"
msgstr "Revoca del certificato valida"
#: g10/trustdb.c:1940 g10/trustdb.c:2659 g10/trustdb.c:2743
msgid "Good certificate"
msgstr "Certificato corretto"
#: g10/trustdb.c:1949
msgid "very strange: no public key\n"
msgstr "molto strano: non ci sono chiavi pubbliche\n"
#: g10/trustdb.c:1997
#, c-format
msgid "hintlist %lu[%d] of %lu does not point to a dir record\n"
msgstr "hintlist %lu[%d] di %lu non punta a un record dir\n"
#: g10/trustdb.c:2003
#, c-format
msgid "lid %lu does not have a key\n"
msgstr "Il lid %lu non ha una chiave\n"
#: g10/trustdb.c:2013
#, c-format
msgid "lid %lu: can't get keyblock: %s\n"
msgstr "lid %lu: impossibile ottenere il keyblock: %s\n"
#: g10/trustdb.c:2070 g10/trustdb.c:2984
#, fuzzy, c-format
msgid "tdbio_search_dir failed: %s\n"
msgstr "rimozione dell'armatura fallita: %s\n"
#: g10/trustdb.c:2223
#, c-format
msgid "key %08lX.%lu: Good subkey binding\n"
msgstr "chiave %08lX.%lu: Legame con la subchiave corretto\n"
#: g10/trustdb.c:2229 g10/trustdb.c:2271
#, c-format
msgid "key %08lX.%lu: Invalid subkey binding: %s\n"
msgstr "chiave %08lX.%lu: Legame con la subchiave non valido: %s\n"
#: g10/trustdb.c:2244
#, c-format
msgid "key %08lX.%lu: Valid key revocation\n"
msgstr "chiave %08lX.%lu: Revoca della chiave valida\n"
#: g10/trustdb.c:2250
#, c-format
msgid "key %08lX.%lu: Invalid key revocation: %s\n"
msgstr "chiave %08lX.%lu: Revoca della chiave non valida: %s\n"
#: g10/trustdb.c:2265
#, c-format
msgid "key %08lX.%lu: Valid subkey revocation\n"
msgstr "chiave %08lX.%lu: Revoca della subchiave valida\n"
#: g10/trustdb.c:2365
msgid "Good self-signature"
msgstr "Autofirma corretta"
#: g10/trustdb.c:2376
msgid "Invalid self-signature"
msgstr "Autofirma non valida"
#: g10/trustdb.c:2386
msgid "Valid user ID revocation skipped due to a newer self signature\n"
msgstr ""
#: g10/trustdb.c:2393
msgid "Valid user ID revocation\n"
msgstr "Revoca dell'user ID valida\n"
#: g10/trustdb.c:2400
msgid "Invalid user ID revocation"
msgstr "Revoca dell'user ID non valida"
#: g10/trustdb.c:2484
msgid "Too many preferences"
msgstr "Troppe preferenze"
#: g10/trustdb.c:2498
#, fuzzy
msgid "Too many preference items"
msgstr "Troppi elementi di preferenza"
#: g10/trustdb.c:2637
msgid "Duplicated certificate - deleted"
msgstr "Certificato doppio - cancellato"
#: g10/trustdb.c:2670
#, fuzzy
msgid "Hmmm, public key lost?"
msgstr "chiave pubblica perduta"
#: g10/trustdb.c:2680 g10/trustdb.c:2763
msgid "Invalid certificate revocation"
msgstr "Certificato di revoca non valido"
#: g10/trustdb.c:2681 g10/trustdb.c:2764
msgid "Invalid certificate"
msgstr "Certificato non valido"
#: g10/trustdb.c:2696
#, c-format
msgid "uid %08lX.%lu/%02X%02X: has shadow dir %lu but is not yet marked.\n"
msgstr ""
#: g10/trustdb.c:2710
#, fuzzy, c-format
msgid "sig record %lu[%d] points to wrong record.\n"
msgstr "Il rec di %lu[%d] nella hintlist di %lu non punta a un record dir\n"
#. that should never happen
#: g10/trustdb.c:2954
#, fuzzy, c-format
msgid "insert_trust_record: keyblock not found: %s\n"
msgstr "chiave %08lX: chiave segreta non trovata: %s\n"
#: g10/trustdb.c:2972
msgid "did not use primary key for insert_trust_record()\n"
msgstr ""
#: g10/ringedit.c:293
#, fuzzy, c-format
msgid "%s: can't create keyring: %s\n"
msgstr "%s: impossibile creare: %s\n"
#: g10/ringedit.c:299 g10/ringedit.c:1264
#, fuzzy, c-format
msgid "%s: keyring created\n"
msgstr "%s: creato un nuovo file delle opzioni\n"
#: g10/ringedit.c:1449
msgid "WARNING: 2 files with confidential information exists.\n"
msgstr ""
#: g10/ringedit.c:1450
#, fuzzy, c-format
msgid "%s is the unchanged one\n"
msgstr "chiavi segrete non cambiate %lu\n"
#: g10/ringedit.c:1451
#, c-format
msgid "%s is the new one\n"
msgstr ""
#: g10/ringedit.c:1452
msgid "Please fix this possible security flaw\n"
msgstr ""
#: g10/skclist.c:94
#, fuzzy, c-format
msgid "skipped '%s': %s\n"
msgstr "%s: saltata: %s\n"
#: g10/skclist.c:100
#, fuzzy, c-format
msgid ""
"skipped '%s': this is a PGP generated ElGamal key which is not secure for "
"signatures!\n"
msgstr ""
"questa è una chiave ElGamal generata da PGP che NON è sicura per le firme!\n"
#. do not overwrite
#: g10/openfile.c:58
#, c-format
msgid "File '%s' exists. "
msgstr "Il file '%s' esiste. "
#: g10/openfile.c:60
msgid "Overwrite (y/N)? "
msgstr "Sovrascrivo (y/N)? "
#: g10/openfile.c:85
msgid "writing to stdout\n"
msgstr "scrivo su stdout\n"
#: g10/openfile.c:134
#, c-format
msgid "assuming signed data in '%s'\n"
msgstr "presumo che i dati firmati siano in '%s'\n"
#: g10/openfile.c:181
#, c-format
msgid "%s: new options file created\n"
msgstr "%s: creato un nuovo file delle opzioni\n"
#: g10/encr-data.c:59
#, fuzzy, c-format
msgid "%s encrypted data\n"
msgstr "cifra dati"
#: g10/encr-data.c:61
#, c-format
msgid "encrypted with unknown algorithm %d\n"
msgstr ""
#: g10/encr-data.c:74
#, fuzzy
msgid ""
"WARNING: Message was encrypted with a weak key in the symmetric cipher.\n"
msgstr ""
"Attenzione: il messaggio era stato crittografato usando una chiave debole\n"
"per il cifrario simmetrico\n"
#: g10/seskey.c:52
msgid "weak key created - retrying\n"
msgstr "creata una chiave debole - riprovo\n"
#: g10/seskey.c:57
#, c-format
msgid "cannot avoid weak key for symmetric cipher; tried %d times!\n"
msgstr ""
"Impossibile evitare una chiave debole per il cifrario simmetrico;\n"
"ho provato %d volte!\n"
#. begin of list
#: g10/helptext.c:45
msgid "edit_ownertrust.value"
msgstr "edit_ownertrust.value"
#: g10/helptext.c:51
msgid "revoked_key.override"
msgstr "revoked_key.override"
#: g10/helptext.c:55
msgid "untrusted_key.override"
msgstr "untrusted_key.override"
#: g10/helptext.c:59
msgid "pklist.user_id.enter"
msgstr "pklist.user_id.enter"
#: g10/helptext.c:63
msgid "keygen.algo"
msgstr "keygen.algo"
#: g10/helptext.c:79
#, fuzzy
msgid "keygen.algo.elg_se"
msgstr "keygen.algo"
#: g10/helptext.c:86
msgid "keygen.size"
msgstr "keygen.size"
#: g10/helptext.c:90
msgid "keygen.size.huge.okay"
msgstr "keygen.size.huge.okay"
#: g10/helptext.c:95
msgid "keygen.size.large.okay"
msgstr "keygen.size.large.okay"
#: g10/helptext.c:100
msgid "keygen.valid"
msgstr "keygen.valid"
#: g10/helptext.c:104
msgid "keygen.valid.okay"
msgstr "keygen.valid.okay"
#: g10/helptext.c:109
msgid "keygen.name"
msgstr "keygen.name"
#: g10/helptext.c:114
msgid "keygen.email"
msgstr "keygen.email"
#: g10/helptext.c:118
msgid "keygen.comment"
msgstr "keygen.comment"
#: g10/helptext.c:123
msgid "keygen.userid.cmd"
msgstr "keygen.userid.cmd"
#: g10/helptext.c:132
msgid "keygen.sub.okay"
msgstr "keygen.sub.okay"
#: g10/helptext.c:136
msgid "sign_uid.okay"
msgstr "sign_uid.okay"
#: g10/helptext.c:141
msgid "change_passwd.empty.okay"
msgstr "change_passwd.empty.okay"
#: g10/helptext.c:146
msgid "keyedit.cmd"
msgstr "keyedit.cmd"
#: g10/helptext.c:150
msgid "keyedit.save.okay"
msgstr "keyedit.save.okay"
#: g10/helptext.c:155
msgid "keyedit.cancel.okay"
msgstr "keyedit.cancel.okay"
#: g10/helptext.c:159
msgid "keyedit.sign_all.okay"
msgstr "keyedit.sign_all.okay"
#: g10/helptext.c:163
msgid "keyedit.remove.uid.okay"
msgstr "keyedit.remove.uid.okay"
#: g10/helptext.c:168
msgid "keyedit.remove.subkey.okay"
msgstr "keyedit.remove.subkey.okay"
#: g10/helptext.c:172
msgid "passphrase.enter"
msgstr "passphrase.enter"
#: g10/helptext.c:179
msgid "passphrase.repeat"
msgstr "passphrase.repeat"
#: g10/helptext.c:183
msgid "detached_signature.filename"
msgstr "detached_signature.filename"
#: g10/helptext.c:187
msgid "openfile.overwrite.okay"
msgstr "openfile.overwrite.okay"
#: g10/helptext.c:201
msgid "No help available"
msgstr "Nessun aiuto disponibile"
#: g10/helptext.c:213
#, c-format
msgid "No help available for '%s'"
msgstr "Nessun aiuto disponibile per '%s'"
#~ msgid "You will see a list of signators etc. here\n"
#~ msgstr "Qui vedrai una lista di firmatari, ecc.\n"
diff --git a/po/pt_BR.po b/po/pt_BR.po
index e5431c181..a68a39607 100644
--- a/po/pt_BR.po
+++ b/po/pt_BR.po
@@ -1,3067 +1,3067 @@
# Portuguese messages for gnupg
# Thiago Jung Bauermann <jungmann@usa.net>, 1998.
# I tried to make this one close to es_ES by Urko Lusa
#
msgid ""
msgstr ""
"POT-Creation-Date: 1998-12-10 20:11+0100\n"
"Content-Type: text/plain; charset=iso-8859-1\n"
"Date: 1998-11-20 23:46:36-0200\n"
"From: Thiago Jung Bauermann <jungmann@usa.net>\n"
"Xgettext-Options: --default-domain=gnupg --directory=.. --add-comments "
"--keyword=_ --keyword=N_ --files-from=./POTFILES.in\n"
"Files: util/secmem.c util/argparse.c cipher/random.c cipher/rand-dummy.c "
"cipher/rand-unix.c cipher/rand-w32.c g10/g10.c g10/pkclist.c g10/keygen.c "
"g10/decrypt.c g10/encode.c g10/import.c g10/keyedit.c g10/keylist.c "
"g10/mainproc.c g10/passphrase.c g10/plaintext.c g10/pref.c g10/seckey-cert.c "
"g10/sig-check.c g10/sign.c g10/trustdb.c g10/verify.c\n"
#: util/secmem.c:77
msgid "Warning: using insecure memory!\n"
msgstr "Aviso: usando memória insegura!\n"
#: util/miscutil.c:143
msgid "yes"
msgstr "sim"
#: util/miscutil.c:144
msgid "yY"
msgstr "sS"
#: util/errors.c:54
msgid "General error"
msgstr "Erro geral"
#: util/errors.c:55
msgid "Unknown packet type"
msgstr "Formato desconhecido"
#: util/errors.c:56
msgid "Unknown version"
msgstr "Versão desconhecida"
#: util/errors.c:57
msgid "Unknown pubkey algorithm"
msgstr "Algoritmo de chave pública desconhecido"
#: util/errors.c:58
msgid "Unknown digest algorithm"
msgstr "Algoritmo de \"digest\" desconhecido"
#: util/errors.c:59
msgid "Bad public key"
msgstr "Chave pública incorreta"
#: util/errors.c:60
msgid "Bad secret key"
msgstr "Chave secreta incorreta"
#: util/errors.c:61
msgid "Bad signature"
msgstr "Assinatura incorreta"
#: util/errors.c:62
msgid "Checksum error"
msgstr "Erro de \"checksum\""
#: util/errors.c:63
msgid "Bad passphrase"
msgstr "Frase secreta incorreta"
#: util/errors.c:64
msgid "Public key not found"
msgstr "Chave pública não encontrada"
#: util/errors.c:65
msgid "Unknown cipher algorithm"
msgstr "Algoritmo de criptografia desconhecido"
#: util/errors.c:66
msgid "Can't open the keyring"
msgstr "Não é possível abrir o anel de chaves"
#: util/errors.c:67
msgid "Invalid packet"
msgstr "Valor inválido"
#: util/errors.c:68
msgid "Invalid armor"
msgstr "Armadura inválida"
#: util/errors.c:69
msgid "No such user id"
msgstr "Identificador de usuário inexistente"
#: util/errors.c:70
msgid "Secret key not available"
msgstr "Chave secreta não disponível"
#: util/errors.c:71
msgid "Wrong secret key used"
msgstr "Chave secreta incorreta"
#: util/errors.c:72
msgid "Not supported"
msgstr "Não suportado"
#: util/errors.c:73
msgid "Bad key"
msgstr "Chave incorreta"
#: util/errors.c:74
msgid "File read error"
msgstr "Erro de leitura"
#: util/errors.c:75
msgid "File write error"
msgstr "Erro de escrita"
#: util/errors.c:76
msgid "Unknown compress algorithm"
msgstr "Algoritmo de compressão desconhecido"
#: util/errors.c:77
msgid "File open error"
msgstr "Erro abrindo arquivo"
#: util/errors.c:78
msgid "File create error"
msgstr "Erro criando arquivo"
#: util/errors.c:79
msgid "Invalid passphrase"
msgstr "Frase secreta inválida"
#: util/errors.c:80
msgid "Unimplemented pubkey algorithm"
msgstr "Algoritmo de chave pública não implementado"
#: util/errors.c:81
msgid "Unimplemented cipher algorithm"
msgstr "Algoritmo de criptografia não implementado"
#: util/errors.c:82
msgid "Unknown signature class"
msgstr "Classe de assinatura desconhecida"
#: util/errors.c:83
msgid "Trust database error"
msgstr "Erro no banco de dados de confiança"
#: util/errors.c:84
msgid "Bad MPI"
msgstr "MPI incorreto"
#: util/errors.c:85
msgid "Resource limit"
msgstr "Limite de recurso"
#: util/errors.c:86
msgid "Invalid keyring"
msgstr "Anel de chaves inválido"
#: util/errors.c:87
msgid "Bad certificate"
msgstr "Certificado incorreto"
#: util/errors.c:88
msgid "Malformed user id"
msgstr "Identificação de usuário mal formada"
#: util/errors.c:89
msgid "File close error"
msgstr "Erro fechando arquivo"
#: util/errors.c:90
msgid "File rename error"
msgstr "Erro renomeando arquivo"
#: util/errors.c:91
msgid "File delete error"
msgstr "Erro deletando arquivo"
#: util/errors.c:92
msgid "Unexpected data"
msgstr "Dados inesperados"
#: util/errors.c:93
msgid "Timestamp conflict"
msgstr "Conflito com \"timestamp\""
#: util/errors.c:94
msgid "Unusable pubkey algorithm"
msgstr "Algoritmo de chave pública inutilizável"
#: util/errors.c:95
msgid "File exists"
msgstr "O arquivo já existe"
#: util/errors.c:96
msgid "Weak key"
msgstr "Chave fraca"
#: util/logger.c:178
#, c-format
msgid "... this is a bug (%s:%d:%s)\n"
msgstr "... isto é um bug (%s:%d:%s)\n"
#: util/logger.c:184
#, c-format
msgid "you found a bug ... (%s:%d)\n"
msgstr "você encontrou um bug ... (%s:%d)\n"
#: cipher/random.c:412
msgid "WARNING: using insecure random number generator!!\n"
msgstr "AVISO: usando gerador de números aleatórios inseguro!\n"
#: cipher/random.c:413
msgid ""
"The random number generator is only a kludge to let\n"
"it run - it is in no way a strong RNG!\n"
"\n"
"DON'T USE ANY DATA GENERATED BY THIS PROGRAM!!\n"
"\n"
msgstr ""
"O gerador de números aleatórios é apenas um \"remendo\"\n"
"para poder compilar - Ele não é seguro!\n"
"\n"
"NÃO USE NENHUM DADO GERADO POR ESTE PROGRAMA!\n"
"\n"
#: cipher/rndlinux.c:116
#, c-format
msgid ""
"\n"
"Not enough random bytes available. Please do some other work to give\n"
"the OS a chance to collect more entropy! (Need %d more bytes)\n"
msgstr ""
"\n"
"Não há bytes aleatórios suficientes. Por favor, faça algum outro trabalho\n"
"para que o sistema possa coletar mais entropia!\n"
"(São necessários mais %d bytes)\n"
#: g10/g10.c:159
msgid ""
"@Commands:\n"
" "
msgstr ""
"@Comandos:\n"
" "
#: g10/g10.c:162
msgid "|[file]|make a signature"
msgstr "|[arquivo]|faz uma assinatura"
#: g10/g10.c:163
msgid "|[file]|make a clear text signature"
msgstr "|[arquivo]|faz uma assinatura em texto puro"
#: g10/g10.c:164
msgid "make a detached signature"
msgstr "faz uma assinatura separada"
#: g10/g10.c:165
msgid "encrypt data"
msgstr "codifica dados"
#: g10/g10.c:166
msgid "encryption only with symmetric cipher"
msgstr "codifica apenas com criptografia simétrica"
#: g10/g10.c:167
msgid "store only"
msgstr "apenas armazena"
#: g10/g10.c:168
msgid "decrypt data (default)"
msgstr "decodifica dados (padrão)"
#: g10/g10.c:169
msgid "verify a signature"
msgstr "verifica uma assinatura"
#: g10/g10.c:171
msgid "list keys"
msgstr "lista as chaves"
#: g10/g10.c:172
msgid "list keys and signatures"
msgstr "lista as chaves e as assinaturas"
#: g10/g10.c:173
msgid "check key signatures"
msgstr "confere as assinaturas das chaves"
#: g10/g10.c:174
msgid "list keys and fingerprints"
msgstr "lista as chaves e as impressões digitais"
#: g10/g10.c:175
msgid "list secret keys"
msgstr "lista as chaves secretas"
#: g10/g10.c:177
msgid "generate a new key pair"
msgstr "gera um novo par de chaves"
#: g10/g10.c:179
msgid "remove key from the public keyring"
msgstr "remove a chave do anel de chaves público"
#: g10/g10.c:181
msgid "sign or edit a key"
msgstr "assina ou edita uma chave"
#: g10/g10.c:182
msgid "generate a revocation certificate"
msgstr "gera um certificado de revogação"
#: g10/g10.c:184
msgid "export keys"
msgstr "exporta as chaves"
#: g10/g10.c:187
msgid "import/merge keys"
msgstr "importa/funde as chaves"
#: g10/g10.c:189
msgid "list only the sequence of packets"
msgstr "lista apenas as seqüências de pacotes"
#: g10/g10.c:192
msgid "export the ownertrust values"
msgstr "exporta os valores de confiança"
#: g10/g10.c:194
msgid "import ownertrust values"
msgstr "importa os valores de confiança"
#: g10/g10.c:196
msgid "|[NAMES]|update the trust database"
msgstr "|[NOMES]|atualiza o banco de dados de confiança"
#: g10/g10.c:198
msgid "|[NAMES]|check the trust database"
msgstr "|[NOMES]|confere o banco de dados de confiança"
#: g10/g10.c:199
msgid "fix a corrupted trust database"
msgstr "conserta um banco de dados de confiança danificado"
#: g10/g10.c:200
msgid "De-Armor a file or stdin"
msgstr "Retira a armadura de um arquivo ou \"stdin\""
#: g10/g10.c:201
msgid "En-Armor a file or stdin"
msgstr "Cria armadura para um arquivo ou \"stdin\""
#: g10/g10.c:202
msgid "|algo [files]|print message digests"
msgstr "|algo [arquivos]|imprime \"digests\" de mensagens"
#: g10/g10.c:203
msgid "print all message digests"
msgstr "imprime todos os \"digests\" de mensagens"
#: g10/g10.c:210
msgid ""
"@\n"
"Options:\n"
" "
msgstr ""
"@\n"
"Opções:\n"
" "
#: g10/g10.c:212
msgid "create ascii armored output"
msgstr "cria uma saída ascii com armadura"
#: g10/g10.c:214
msgid "use this user-id to sign or decrypt"
msgstr "usa este identificador de usuário para assinar ou decodificar"
#: g10/g10.c:215
msgid "use this user-id for encryption"
msgstr "usa este identificador de usuário para codificar"
#: g10/g10.c:216
msgid "|N|set compress level N (0 disables)"
msgstr "|N|estabelece nível de compressão N (0 desabilita)"
#: g10/g10.c:218
msgid "use canonical text mode"
msgstr "usa modo de texto canônico"
#: g10/g10.c:220
msgid "use as output file"
msgstr "usa como arquivo de saída"
#: g10/g10.c:221
msgid "verbose"
msgstr "prolixo"
#: g10/g10.c:222
msgid "be somewhat more quiet"
msgstr "ser mais silencioso"
#: g10/g10.c:223
msgid "force v3 signatures"
msgstr "força assinaturas v3"
#. { oDryRun, "dry-run", 0, N_("do not make any changes") },
#: g10/g10.c:225
msgid "batch mode: never ask"
msgstr "processo de lote: nunca perguntar"
#: g10/g10.c:226
msgid "assume yes on most questions"
msgstr "assumir sim para a maioria das perguntas"
#: g10/g10.c:227
msgid "assume no on most questions"
msgstr "assumir não para a maioria das perguntas"
#: g10/g10.c:228
msgid "add this keyring to the list of keyrings"
msgstr "adiciona este anel de chaves à lista de anéis de chaves"
#: g10/g10.c:229
msgid "add this secret keyring to the list"
msgstr "adiciona este anel de chaves secreto à lista"
#: g10/g10.c:230
msgid "|NAME|use NAME as default secret key"
msgstr "|NOME|usa NOME como chave secreta padrão"
#: g10/g10.c:231
#, fuzzy
msgid "|NAME|set terminal charset to NAME"
msgstr "|NOME| estabelece mapa de caracteres do terminal para NOME"
#: g10/g10.c:232
msgid "read options from file"
msgstr "lê opções do arquivo"
#: g10/g10.c:234
msgid "set debugging flags"
msgstr "estabelece parâmetros de depuração"
#: g10/g10.c:235
msgid "enable full debugging"
msgstr "habilita depuração completa"
#: g10/g10.c:236
msgid "|FD|write status info to this FD"
msgstr "|DA|escreve informações de status para este DA"
#: g10/g10.c:237
msgid "do not write comment packets"
msgstr "não escreve pacotes de comentário"
#: g10/g10.c:238
msgid "(default is 1)"
msgstr "(o padrão é 1)"
#: g10/g10.c:239
msgid "(default is 3)"
msgstr "(o padrão é 3)"
#: g10/g10.c:241
msgid "|KEYID|ulimately trust this key"
msgstr ""
#: g10/g10.c:242
msgid "|FILE|load extension module FILE"
msgstr "|ARQUIVO|carrega módulo de extensão ARQUIVO"
#: g10/g10.c:243
msgid "emulate the mode described in RFC1991"
msgstr "emula o modo descrito no RFC1991"
#: g10/g10.c:244
msgid "|N|use passphrase mode N"
msgstr "|N|usa frase secreta modo N"
#: g10/g10.c:246
msgid "|NAME|use message digest algorithm NAME for passphrases"
msgstr ""
"|NOME|usa algoritmo de \"digest\" de mensagens NOME para\n"
"frases secretas"
#: g10/g10.c:248
msgid "|NAME|use cipher algorithm NAME for passphrases"
msgstr ""
"|NOME|usa algoritmo de criptografia NOME para\n"
"frases secretas"
#: g10/g10.c:250
msgid "|NAME|use cipher algorithm NAME"
msgstr "|NOME|usa algoritmo de criptografia NOME"
#: g10/g10.c:251
msgid "|NAME|use message digest algorithm NAME"
msgstr "|NOME|usa algoritmo de \"digest\" de mensagens NOME"
#: g10/g10.c:252
msgid "|N|use compress algorithm N"
msgstr "|N|usa algoritmo de compressão N"
#: g10/g10.c:253
msgid "throw keyid field of encrypted packets"
msgstr "elimina o campo keyid dos pacotes codificados"
#: g10/g10.c:261
msgid ""
"@\n"
"Examples:\n"
"\n"
" -se -r Bob [file] sign and encrypt for user Bob\n"
" --clearsign [file] make a clear text signature\n"
" --detach-sign [file] make a detached signature\n"
" --list-keys [names] show keys\n"
" --fingerprint [names] show fingerprints\n"
msgstr ""
"@\n"
"Exemplos:\n"
"\n"
" -se -r Bob [arquivo] assina e codifica para usuário Bob\n"
" --clearsign [arquivo] cria uma assinatura em texto puro\n"
" --detach-sign [arquivo] cria uma assinatura separada\n"
" --list-keys [nomes] mostra chaves\n"
" --fingerprint [nomes] mostra impressões digitais\n"
#: g10/g10.c:339
msgid "Please report bugs to <gnupg-bugs@gnu.org>.\n"
msgstr "Por favor comunique bugs para <gnupg-bugs@gnu.org>.\n"
#: g10/g10.c:344
msgid "Usage: gpgm [options] [files] (-h for help)"
msgstr "Uso: gpgm [opções] [arquivos] (-h para ajuda)"
#: g10/g10.c:346
msgid "Usage: gpg [options] [files] (-h for help)"
msgstr "Uso: gpg [opções] [arquivos] (-h para ajuda)"
#: g10/g10.c:351
msgid ""
"Syntax: gpgm [options] [files]\n"
"GnuPG maintenance utility\n"
msgstr ""
"Sintaxe: gpgm [opções] [arquivos]\n"
"Utilitário de manutenção do GnuPG\n"
#: g10/g10.c:354
msgid ""
"Syntax: gpg [options] [files]\n"
"sign, check, encrypt or decrypt\n"
"default operation depends on the input data\n"
msgstr ""
"Sintaxe: gpg [opções] [arquivos]\n"
"assina, verifica, codifica ou decodifica\n"
"a operação padrão depende dos dados de entrada\n"
#: g10/g10.c:360
msgid ""
"\n"
"Supported algorithms:\n"
msgstr ""
"\n"
"Algoritmos suportados:\n"
#: g10/g10.c:435
msgid "usage: gpgm [options] "
msgstr "Uso: gpgm [opções] "
#: g10/g10.c:437
msgid "usage: gpg [options] "
msgstr "uso: gpg [opções] "
#: g10/g10.c:478
msgid "conflicting commands\n"
msgstr "comandos conflitantes\n"
#: g10/g10.c:616
#, c-format
msgid "NOTE: no default option file '%s'\n"
msgstr "NOTA: arquivo de opções padrão '%s' inexistente\n"
#: g10/g10.c:620
#, c-format
msgid "option file '%s': %s\n"
msgstr "arquivo de opções '%s': %s\n"
#: g10/g10.c:627
#, c-format
msgid "reading options from '%s'\n"
msgstr "lendo opções de '%s'\n"
#: g10/g10.c:776
#, c-format
msgid "%s is not a valid character set\n"
msgstr "%s não é um mapa de caracteres válido\n"
#: g10/g10.c:810 g10/g10.c:822
msgid "selected cipher algorithm is invalid\n"
msgstr "algoritmo de criptografia selecionado não é válido\n"
#: g10/g10.c:816 g10/g10.c:828
msgid "selected digest algorithm is invalid\n"
msgstr "algoritmo de \"digest\" selecionado não é válido\n"
#: g10/g10.c:831
#, c-format
msgid "compress algorithm must be in range %d..%d\n"
msgstr "algoritmo de compressão deve estar na faixa %d..%d\n"
#: g10/g10.c:833
msgid "completes-needed must be greater than 0\n"
msgstr "completes-needed deve ser maior que 0\n"
#: g10/g10.c:835
msgid "marginals-needed must be greater than 1\n"
msgstr "marginals-needed deve ser maior que 1\n"
#: g10/g10.c:837
msgid "max-cert-depth must be in range 1 to 255\n"
msgstr "max-cert-depth deve estar na faixa 1 a 255\n"
#: g10/g10.c:840
msgid "NOTE: simple S2K mode (0) is strongly discouraged\n"
msgstr "NOTA: o modo S2K simples (0) não é recomendável\n"
#: g10/g10.c:844
msgid "invalid S2K mode; must be 0, 1 or 3\n"
msgstr "modo S2K inválido: deve ser 0, 1 ou 3\n"
#: g10/g10.c:927
#, c-format
msgid "failed to initialize the TrustDB: %s\n"
msgstr "falha ao inicializar o banco de dados de confiança: %s\n"
#: g10/g10.c:933
msgid "--store [filename]"
msgstr "--store [nome_do_arquivo]"
#: g10/g10.c:941
msgid "--symmetric [filename]"
msgstr "--symmetric [nome_do_arquivo]"
#: g10/g10.c:949
msgid "--encrypt [filename]"
msgstr "--encrypt [nome_do_arquivo]"
#: g10/g10.c:962
msgid "--sign [filename]"
msgstr "--sign [nome_do_arquivo]"
#: g10/g10.c:975
msgid "--sign --encrypt [filename]"
msgstr "--sign --encrypt [nome_do_arquivo]"
#: g10/g10.c:989
msgid "--clearsign [filename]"
msgstr "--clearsign [nome_do_arquivo]"
#: g10/g10.c:1001
msgid "--decrypt [filename]"
msgstr "--decrypt [nome_do_arquivo]"
#: g10/g10.c:1010
msgid "--edit-key username [commands]"
msgstr "--edit-key nome_do_usuário [comandos]"
#: g10/g10.c:1026
msgid "--delete-secret-key username"
msgstr "--delete-secret-key nome_do_usuário"
#: g10/g10.c:1029
msgid "--delete-key username"
msgstr "--delete-key nome_do_usuário"
#: g10/encode.c:216 g10/g10.c:1052 g10/sign.c:301
#, c-format
msgid "can't open %s: %s\n"
msgstr "impossível abrir %s: %s\n"
#: g10/g10.c:1063
msgid "-k[v][v][v][c] [userid] [keyring]"
msgstr "-k[v][v][v][c] [id_do_usuário] [anel_de_chaves]"
#: g10/g10.c:1120
#, c-format
msgid "dearmoring failed: %s\n"
msgstr "retirada de armadura falhou: %s\n"
#: g10/g10.c:1128
#, c-format
msgid "enarmoring failed: %s\n"
msgstr "criação de armadura falhou: %s\n"
#: g10/g10.c:1194
#, c-format
msgid "invalid hash algorithm '%s'\n"
msgstr "algoritmo de distribuição inválido '%s'\n"
#: g10/g10.c:1273
msgid "[filename]"
msgstr "[nome_do_arquivo]"
#: g10/g10.c:1277
msgid "Go ahead and type your message ...\n"
msgstr "Vá em frente e digite sua mensagem ...\n"
#: g10/decrypt.c:59 g10/g10.c:1280 g10/verify.c:66
#, c-format
msgid "can't open '%s'\n"
msgstr "impossível abrir '%s'\n"
#: g10/armor.c:344 g10/armor.c:391
msgid "armor header: "
msgstr "cabeçalho de armadura: "
#: g10/armor.c:355
msgid "invalid clearsig header\n"
msgstr "cabeçalho de assinatura em texto puro inválido\n"
#: g10/armor.c:382
msgid "invalid armor header: "
msgstr "cabeçalho de armadura inválido: "
#: g10/armor.c:460
#, c-format
msgid "armor: %s\n"
msgstr "armadura: %s\n"
#: g10/armor.c:533
msgid "invalid dash escaped line: "
msgstr "linha com hífen inválida: "
#: g10/armor.c:602
msgid "invalid clear text header: "
msgstr "cabeçalho de texto puro inválido: "
#: g10/armor.c:845
#, c-format
msgid "invalid radix64 character %02x skipped\n"
msgstr "caractere radix64 inválido %02x ignorado\n"
#: g10/armor.c:878
msgid "premature eof (no CRC)\n"
msgstr "fim de arquivo prematuro (sem CRC)\n"
#: g10/armor.c:897
msgid "premature eof (in CRC)\n"
msgstr "fim de arquivo prematuro (no CRC)\n"
#: g10/armor.c:901
msgid "malformed CRC\n"
msgstr "CRC malformado\n"
#: g10/armor.c:905
#, c-format
msgid "CRC error; %06lx - %06lx\n"
msgstr "erro de CRC; %06lx - %06lx\n"
#: g10/armor.c:924
msgid "premature eof (in Trailer)\n"
msgstr "fim de arquivo prematuro (no \"Trailer\")\n"
#: g10/armor.c:928
msgid "error in trailer line\n"
msgstr "erro na linha \"trailer\"\n"
#: g10/armor.c:1182
msgid "no valid RFC1991 or OpenPGP data found.\n"
msgstr "nenum dado RFC1991 ou OpenPGP válido encontrado.\n"
#: g10/pkclist.c:121
#, c-format
msgid ""
"No trust value assigned to %lu:\n"
"%4u%c/%08lX %s \""
msgstr ""
"Nenhum valor de confiança designado para %lu:\n"
"%4u%c/%08lX %s \""
#: g10/pkclist.c:131
msgid ""
"Please decide how far you trust this user to correctly\n"
"verify other users' keys (by looking at passports,\n"
"checking fingerprints from different sources...)?\n"
"\n"
" 1 = Don't know\n"
" 2 = I do NOT trust\n"
" 3 = I trust marginally\n"
" 4 = I trust fully\n"
" s = please show me more information\n"
msgstr ""
"Por favor decida quanto você confia neste usuário para\n"
"verificar corretamente as chaves de outros usuários\n"
"(olhando em passaportes, checando impressões digitais\n"
"de outras fontes...)?\n"
"\n"
" 1 = Não sei\n"
" 2 = Eu NÃO confio\n"
" 3 = Eu confio marginalmente\n"
" 4 = Eu confio completamente\n"
" 5 = Mostrar mais informação\n"
#: g10/pkclist.c:140
msgid " m = back to the main menu\n"
msgstr " m = volta ao menu principal\n"
#. a string with valid answers
#: g10/pkclist.c:145
msgid "sSmM"
msgstr "iImM"
#: g10/pkclist.c:149
msgid "Your decision? "
msgstr "Sua decisão? "
#: g10/pkclist.c:169
msgid "Certificates leading to an ultimately trusted key:\n"
msgstr "Certificados que levam a uma chave confiada plenamente:\n"
#: g10/pkclist.c:197
msgid ""
"Could not find a valid trust path to the key. Let's see whether we\n"
"can assign some missing owner trust values.\n"
"\n"
msgstr ""
"Não foi possível encontrar uma rota de confiança válida para a chave.\n"
"Vamos ver se é possível designar alguns valores de confiança perdidos.\n"
"\n"
#: g10/pkclist.c:219
msgid ""
"No path leading to one of our keys found.\n"
"\n"
msgstr "Nenhuma rota que leva a uma de nossas chaves encontrada.\n"
#: g10/pkclist.c:221
msgid ""
"No certificates with undefined trust found.\n"
"\n"
msgstr ""
"Nenhum certificado com confiança indefinida encontrado.\n"
"\n"
#: g10/pkclist.c:223
msgid ""
"No trust values changed.\n"
"\n"
msgstr ""
"Nenhum valor de confiança modificado.\n"
"\n"
#: g10/pkclist.c:238
#, c-format
msgid "key %08lX: key has been revoked!\n"
msgstr "chave %08lX: a chave foi revogada!\n"
#: g10/pkclist.c:244 g10/pkclist.c:335
msgid "Use this key anyway? "
msgstr "Usa esta chave de qualquer modo?"
#: g10/pkclist.c:266
#, c-format
msgid "%08lX: key has expired\n"
msgstr "%08lX: a chave expirou\n"
#: g10/pkclist.c:272
#, c-format
msgid "%08lX: no info to calculate a trust probability\n"
msgstr "%08lX: sem informação para calcular probabilidade de confiança\n"
#: g10/pkclist.c:288
#, c-format
msgid "%08lX: We do NOT trust this key\n"
msgstr "%08lX: Nós NÃO confiamos nesta chave\n"
#: g10/pkclist.c:294
#, fuzzy, c-format
msgid ""
"%08lX: It is not sure that this key really belongs to the owner\n"
"but it is accepted anyway\n"
msgstr ""
"%08lX: Não se tem certeza de que esta chave realmente pertence ao dono\n"
"mas é aceitada de qualquer modo\n"
#: g10/pkclist.c:300
msgid "This key probably belongs to the owner\n"
msgstr "Esta chave provavelmente pertence ao dono\n"
#: g10/pkclist.c:305
msgid "This key belongs to us\n"
msgstr "Esta chave pertence a nós (nós temos a chave secreta)\n"
#: g10/pkclist.c:330
msgid ""
"It is NOT certain that the key belongs to its owner.\n"
"If you *really* know what you are doing, you may answer\n"
"the next question with yes\n"
"\n"
msgstr ""
"Não se tem certeza de que esta chave pertence a seu dono.\n"
"Se você *realmente* sabe o que está fazendo, pode responder\n"
"afirmativamente à próxima pergunta\n"
"\n"
#: g10/pkclist.c:339
msgid "WARNING: Using untrusted key!\n"
msgstr "AVISO: Usando chave não confiável!\n"
#: g10/pkclist.c:375
msgid "WARNING: This key has been revoked by its owner!\n"
msgstr "AVISO: Esta chave foi revogada pelo seu dono!\n"
#: g10/pkclist.c:376
msgid " This could mean that the signature is forgery.\n"
msgstr " Isto pode significar que a assinatura é falsificada.\n"
#: g10/pkclist.c:397
msgid "Note: This key has expired!\n"
msgstr "Nota: Esta chave expirou!\n"
#: g10/pkclist.c:404
msgid "WARNING: This key is not certified with a trusted signature!\n"
msgstr "AVISO: Esta chave não está certificada com uma assinatura confiável!\n"
#: g10/pkclist.c:406
msgid ""
" There is no indication that the signature belongs to the owner.\n"
msgstr " Não há indicação de que a assinatura pertence ao dono.\n"
#: g10/pkclist.c:421
msgid "WARNING: We do NOT trust this key!\n"
msgstr "AVISO: Nós NÃO confiamos nesta chave!\n"
#: g10/pkclist.c:422
msgid " The signature is probably a FORGERY.\n"
msgstr " A assinatura é provavelmente uma FALSIFICAÇÃO.\n"
#: g10/pkclist.c:429
msgid ""
"WARNING: This key is not certified with sufficiently trusted signatures!\n"
msgstr "AVISO: Esta chave não está certificada com assinaturas confiáveis!\n"
#: g10/pkclist.c:432
msgid " It is not certain that the signature belongs to the owner.\n"
msgstr " Não se tem certeza de que a assinatura pertence ao dono.\n"
#: g10/pkclist.c:477
msgid ""
"You did not specify a user ID. (you may use \"-r\")\n"
"\n"
msgstr ""
"Você não especificou um ID de usuário. (pode-se usar \"-r\")\n"
"\n"
#: g10/pkclist.c:482
msgid "Enter the user ID: "
msgstr "Digite o identificador de usuário:"
#: g10/pkclist.c:493
msgid "No such user ID.\n"
msgstr "Identificador de usuário inexistente.\n"
#: g10/pkclist.c:527 g10/pkclist.c:554
#, c-format
msgid "%s: skipped: %s\n"
msgstr "%s: ignorado: %s\n"
#: g10/pkclist.c:535
#, c-format
msgid "%s: error checking key: %s\n"
msgstr "%s: erro verificando chave: %s\n"
#: g10/pkclist.c:561
msgid "no valid addressees\n"
msgstr "nenhum endereço válido\n"
#: g10/keygen.c:124
msgid "writing self signature\n"
msgstr "escrevendo auto-assinatura\n"
#: g10/keygen.c:162
msgid "writing key binding signature\n"
msgstr "escrevendo assinatura ligada a uma chave\n"
#: g10/keygen.c:388
msgid "Please select what kind of key you want:\n"
msgstr "Por favor selecione o tipo de chave desejado:\n"
#: g10/keygen.c:390
#, c-format
msgid " (%d) DSA and ElGamal (default)\n"
msgstr " (%d) DSA e ElGamal (padrão)\n"
#: g10/keygen.c:391
#, c-format
msgid " (%d) DSA (sign only)\n"
msgstr " (%d) DSA (apenas assinatura)\n"
#: g10/keygen.c:393
#, c-format
msgid " (%d) ElGamal (encrypt only)\n"
msgstr " (%d) ElGamal (apenas criptografia)\n"
#: g10/keygen.c:394
#, c-format
msgid " (%d) ElGamal (sign and encrypt)\n"
msgstr " (%d) ElGamal (assinatura e criptografia)\n"
#: g10/keygen.c:396
#, c-format
msgid " (%d) ElGamal in a v3 packet\n"
msgstr " (%d) ElGamal em um pacote v3\n"
#: g10/keygen.c:401
msgid "Your selection? "
msgstr "Sua opção? "
#: g10/keygen.c:411
#, fuzzy
msgid "Do you really want to create a sign and encrypt key? "
msgstr "Você realmente quer deletar as chaves selecionadas? "
#: g10/keygen.c:432
msgid "Invalid selection.\n"
msgstr "Opção inválida.\n"
#: g10/keygen.c:444
#, c-format
msgid ""
"About to generate a new %s keypair.\n"
" minimum keysize is 768 bits\n"
" default keysize is 1024 bits\n"
" highest suggested keysize is 2048 bits\n"
msgstr ""
"Prestes a gerar novo par de chaves %s.\n"
" tamanho mínimo é 768 bits\n"
" tamanho padrão é 1024 bits\n"
" tamanho máximo sugerido é 2048 bits\n"
#: g10/keygen.c:451
msgid "What keysize do you want? (1024) "
msgstr "Que tamanho de chave você quer? (1024) "
#: g10/keygen.c:456
msgid "DSA only allows keysizes from 512 to 1024\n"
msgstr "DSA permite apenas tamanhos de 512 a 1024\n"
#: g10/keygen.c:458
msgid "keysize too small; 768 is smallest value allowed.\n"
msgstr "tamanho muito pequeno; 768 é o valor mínimo permitido.\n"
#: g10/keygen.c:461
msgid ""
"Keysizes larger than 2048 are not suggested because\n"
"computations take REALLY long!\n"
msgstr ""
"Tamanhos de chave maiores que 2048 não são recomendados\n"
"porque o tempo de computação é REALMENTE longo!\n"
#: g10/keygen.c:464
msgid "Are you sure that you want this keysize? "
msgstr "Você tem certeza de que quer este tamanho de chave? "
#: g10/keygen.c:465
msgid ""
"Okay, but keep in mind that your monitor and keyboard radiation is also very "
"vulnerable to attacks!\n"
msgstr ""
"Tudo bem, mas tenha em mente que a radiação de seu monitor e teclado também "
"é vulnerável a ataques!\n"
#: g10/keygen.c:473
msgid "Do you really need such a large keysize? "
msgstr "Você realmente precisa de uma chave tão grande? "
#: g10/keygen.c:479
#, c-format
msgid "Requested keysize is %u bits\n"
msgstr "O tamanho de chave pedido é %u bits\n"
#: g10/keygen.c:482 g10/keygen.c:486
#, c-format
msgid "rounded up to %u bits\n"
msgstr "arredondado para %u bits\n"
#: g10/keygen.c:499
msgid ""
"Please specify how long the key should be valid.\n"
" 0 = key does not expire\n"
" <n> = key expires in n days\n"
" <n>w = key expires in n weeks\n"
" <n>m = key expires in n months\n"
" <n>y = key expires in n years\n"
msgstr ""
"Por favor especifique por quanto tempo a chave deve ser válida.\n"
" 0 = chave não expira\n"
" <n> = chave expira em n dias\n"
" <n>w = chave expira em n semanas\n"
" <n>m = chave expira em n meses\n"
" <n>y = chave expira em n anos\n"
#: g10/keygen.c:514
msgid "Key is valid for? (0) "
msgstr "A chave é valida por? (0) "
#: g10/keygen.c:525
msgid "invalid value\n"
msgstr "valor inválido\n"
#: g10/keygen.c:530
msgid "Key does not expire at all\n"
msgstr "A chave não expira nunca\n"
#. print the date when the key expires
#: g10/keygen.c:536
#, c-format
msgid "Key expires at %s\n"
msgstr "A chave expira em %s\n"
#: g10/keygen.c:542
msgid "Is this correct (y/n)? "
msgstr "Está correto (s/n)? "
#: g10/keygen.c:584
msgid ""
"\n"
"You need a User-ID to identify your key; the software constructs the user "
"id\n"
"from Real Name, Comment and Email Address in this form:\n"
" \"Heinrich Heine (Der Dichter) <heinrichh@duesseldorf.de>\"\n"
"\n"
msgstr ""
"\n"
"Você precisa de um identificador de usuário para identificar sua chave; o\n"
"programa constrói o identificador a partir do Nome Completo, Comentário e\n"
"Endereço Eletrônico desta forma:\n"
" \"Heinrich Heine (Der Dichter) <heinrichh@duesseldorf.de>\"\n"
"\n"
#: g10/keygen.c:595
msgid "Real name: "
msgstr "Nome completo: "
#: g10/keygen.c:599
msgid "Invalid character in name\n"
msgstr "Caractere inválido no nome\n"
#: g10/keygen.c:601
msgid "Name may not start with a digit\n"
msgstr "O nome não deve começar com um dígito\n"
#: g10/keygen.c:603
msgid "Name must be at least 5 characters long\n"
msgstr "O nome deve ter pelo menos 5 caracteres\n"
#: g10/keygen.c:611
msgid "Email address: "
msgstr "Endereço de correio eletrônico: "
#: g10/keygen.c:623
msgid "Not a valid email address\n"
msgstr "Endereço eletrônico inválido\n"
#: g10/keygen.c:631
msgid "Comment: "
msgstr "Comentário: "
#: g10/keygen.c:637
msgid "Invalid character in comment\n"
msgstr "Caractere inválido no comentário\n"
#: g10/keygen.c:657
#, c-format
msgid ""
"You selected this USER-ID:\n"
" \"%s\"\n"
"\n"
msgstr ""
"Você selecionou este identificador de usuário:\n"
" \"%s\"\n"
"\n"
#: g10/keygen.c:660
msgid "NnCcEeOoQq"
msgstr "NnCcEeVvSs"
#: g10/keygen.c:670
msgid "Change (N)ame, (C)omment, (E)mail or (O)kay/(Q)uit? "
msgstr "Muda (N)ome, (C)omentário, (E)ndereço ou (V)álido/(S)air? "
#: g10/keygen.c:722
msgid ""
"You need a Passphrase to protect your secret key.\n"
"\n"
msgstr ""
"Você precisa de uma frase secreta para proteger sua chave.\n"
"\n"
#: g10/keyedit.c:389 g10/keygen.c:730
msgid "passphrase not correctly repeated; try again.\n"
msgstr "A frase secreta não foi repetida corretamente; tente outra vez.\n"
#: g10/keygen.c:736
msgid ""
"You don't want a passphrase - this is probably a *bad* idea!\n"
"I will do it anyway. You can change your passphrase at any time,\n"
"using this program with the option \"--edit-key\".\n"
"\n"
msgstr ""
"Você não quer uma frase secreta - provavelmente isto é uma *má* idéia!\n"
"Vou fazer isso de qualquer modo. Você pode mudar sua frase secreta a\n"
"qualquer hora, usando este programa com a opção \"--edit-key\".\n"
"\n"
#: g10/keygen.c:757
msgid ""
"We need to generate a lot of random bytes. It is a good idea to perform\n"
"some other action (work in another window, move the mouse, utilize the\n"
"network and the disks) during the prime generation; this gives the random\n"
"number generator a better chance to gain enough entropy.\n"
msgstr ""
"Precisamos gerar muitos bytes aleatórios. É uma boa idéia realizar outra\n"
"atividade (trabalhar em outra janela, mover o mouse, usar a rede e os "
"disco)\n"
"durante a geração dos números primos; isso dá ao gerador de números "
"aleatórios\n"
"uma chance melhor de conseguir entropia suficiente.\n"
#: g10/keygen.c:827
msgid "Key generation can only be used in interactive mode\n"
msgstr "A geração de chaves só pode ser feita em modo interativo\n"
#: g10/keygen.c:835
msgid "DSA keypair will have 1024 bits.\n"
msgstr "O par de chaves DSA terá 1024 bits.\n"
#: g10/keygen.c:841
msgid "Key generation cancelled.\n"
msgstr "Geração de chaves cancelada.\n"
#: g10/keygen.c:851
#, c-format
msgid "writing public certificate to '%s'\n"
msgstr "escrevendo certificado público para '%s'\n"
#: g10/keygen.c:852
#, c-format
msgid "writing secret certificate to '%s'\n"
msgstr "escrevendo certificado privado para '%s'\n"
#: g10/keygen.c:929
msgid "public and secret key created and signed.\n"
msgstr "chaves pública e privada criadas e assinadas.\n"
#: g10/keygen.c:931
msgid ""
"Note that this key cannot be used for encryption. You may want to use\n"
"the command \"--add-key\" to generate a secondary key for this purpose.\n"
msgstr ""
"Note que esta chave não pode ser usada para criptografia. Você pode usar\n"
"o comando \"--add-key\" para gerar uma chave secundária para esse "
"propósito.\n"
#: g10/keygen.c:945 g10/keygen.c:1030
#, c-format
msgid "Key generation failed: %s\n"
msgstr "A geração de chaves falhou: %s\n"
#: g10/keygen.c:1008
msgid "Really create? "
msgstr "Realmente criar? "
#: g10/encode.c:88 g10/openfile.c:81 g10/openfile.c:158 g10/tdbio.c:445
#: g10/tdbio.c:504
#, c-format
msgid "%s: can't open: %s\n"
msgstr "%s: impossível abrir: %s\n"
#: g10/encode.c:107
#, c-format
msgid "error creating passphrase: %s\n"
msgstr "erro criando frase secreta: %s\n"
#: g10/encode.c:155 g10/encode.c:269
#, c-format
msgid "%s: WARNING: empty file\n"
msgstr "%s: AVISO: arquivo vazio\n"
#: g10/encode.c:222
#, c-format
msgid "reading from '%s'\n"
msgstr "lendo de '%s'\n"
#: g10/encode.c:397
#, fuzzy, c-format
msgid "%s/%s encrypted for: %s\n"
msgstr "%s codificado para: %s\n"
#: g10/export.c:114
#, fuzzy, c-format
msgid "%s: user not found: %s\n"
msgstr "%s: usuário não encontrado\n"
#: g10/export.c:123
#, fuzzy, c-format
msgid "certificate read problem: %s\n"
msgstr "erro de leitura do usuário '%s': %s\n"
#: g10/export.c:132
#, fuzzy, c-format
msgid "key %08lX: not a rfc2440 key - skipped\n"
msgstr "chave %08lX: chave secreta sem chave pública - ignorada\n"
#: g10/export.c:174
msgid "WARNING: nothing exported\n"
msgstr "AVISO: nada exportado\n"
#: g10/getkey.c:164
msgid "too many entries in pk cache - disabled\n"
msgstr "entradas demais no cache pk - desabilitado\n"
#: g10/getkey.c:263
msgid "too many entries in unk cache - disabled\n"
msgstr "entradas demais no cache unk - desabilitado\n"
#: g10/getkey.c:989
#, c-format
msgid "using secondary key %08lX instead of primary key %08lX\n"
msgstr "usando chave secundária %08lX ao invés de chave primária %08lX\n"
#: g10/import.c:129 g10/trustdb.c:1166
#, c-format
msgid "can't open file: %s\n"
msgstr "impossível abrir arquivo: %s\n"
#: g10/import.c:145
#, c-format
msgid "skipping block of type %d\n"
msgstr "ignorando bloco do tipo %d\n"
#: g10/import.c:152 g10/trustdb.c:1425 g10/trustdb.c:1494
#, c-format
msgid "%lu keys so far processed\n"
msgstr "%lu chaves processadas até agora\n"
#: g10/import.c:157 g10/trustdb.c:1242
#, c-format
msgid "read error: %s\n"
msgstr "erro de leitura: %s\n"
#: g10/import.c:159
#, c-format
msgid "Total number processed: %lu\n"
msgstr "Número total processado: %lu\n"
#: g10/import.c:161
#, c-format
msgid " w/o user IDs: %lu\n"
msgstr " sem IDs de usuários: %lu\n"
#: g10/import.c:163
#, c-format
msgid " imported: %lu"
msgstr " importados: %lu"
#: g10/import.c:169
#, c-format
msgid " unchanged: %lu\n"
msgstr " não modificados: %lu\n"
#: g10/import.c:171
#, c-format
msgid " new user IDs: %lu\n"
msgstr " novos IDs de usuários: %lu\n"
#: g10/import.c:173
#, c-format
msgid " new subkeys: %lu\n"
msgstr " novas subchaves: %lu\n"
#: g10/import.c:175
#, c-format
msgid " new signatures: %lu\n"
msgstr " novas assinaturas: %lu\n"
#: g10/import.c:177
#, c-format
msgid " new key revocations: %lu\n"
msgstr " novas revogações de chaves: %lu\n"
#: g10/import.c:179
#, c-format
msgid " secret keys read: %lu\n"
msgstr " chaves secretas lidas: %lu\n"
#: g10/import.c:181
#, c-format
msgid " secret keys imported: %lu\n"
msgstr " chaves secretas importadas: %lu\n"
#: g10/import.c:183
#, c-format
msgid " secret keys unchanged: %lu\n"
msgstr " chaves secretas não modificadas: %lu\n"
#: g10/import.c:325 g10/import.c:517
#, c-format
msgid "key %08lX: no user id\n"
msgstr "chave %08lX: sem id de usuário\n"
#: g10/import.c:336
#, c-format
msgid "key %08lX: no valid user ids\n"
msgstr "chave %08lX: sem ids de usuários válidos\n"
#: g10/import.c:338
msgid "this may be caused by a missing self-signature\n"
msgstr "isto pode ser causado por falta de auto-assinatura\n"
#: g10/import.c:349 g10/import.c:585
#, c-format
msgid "key %08lX: public key not found: %s\n"
msgstr "chave %08lX: chave pública não encontrada: %s\n"
#: g10/import.c:355
msgid "no default public keyring\n"
msgstr "sem anel de chaves público padrão\n"
#: g10/import.c:359 g10/openfile.c:105 g10/sign.c:205 g10/sign.c:569
#, c-format
msgid "writing to '%s'\n"
msgstr "escrevendo para '%s'\n"
#: g10/import.c:363 g10/import.c:423 g10/import.c:639
#, c-format
msgid "can't lock public keyring: %s\n"
msgstr "impossível bloquear anel de chaves público: %s\n"
#: g10/import.c:366
#, c-format
msgid "can't write to keyring: %s\n"
msgstr "impossível escrever para o anel de chaves: %s\n"
#: g10/import.c:370
#, c-format
msgid "key %08lX: public key imported\n"
msgstr "chave %08lX: chave pública importada\n"
#: g10/import.c:383
#, c-format
msgid "key %08lX: doesn't match our copy\n"
msgstr "chave %08lX: não corresponde à nossa cópia\n"
#: g10/import.c:396 g10/import.c:594
#, c-format
msgid "key %08lX: can't locate original keyblock: %s\n"
msgstr "chave %08lX: impossível localizar bloco de chaves original: %s\n"
#: g10/import.c:403 g10/import.c:601
#, c-format
msgid "key %08lX: can't read original keyblock: %s\n"
msgstr "chave %08lX: impossível ler bloco de chaves original: %s\n"
#: g10/import.c:420 g10/import.c:532 g10/import.c:636
msgid "writing keyblock\n"
msgstr "escrevendo bloco de chaves\n"
#: g10/import.c:426 g10/import.c:642
#, c-format
msgid "can't write keyblock: %s\n"
msgstr "impossível escrever bloco de chaves: %s\n"
#: g10/import.c:431
#, c-format
msgid "key %08lX: 1 new user-id\n"
msgstr "chave %8lX: 1 novo id de usuário\n"
#: g10/import.c:434
#, c-format
msgid "key %08lX: %d new user-ids\n"
msgstr "chave %08lX: %d novos ids de usuários\n"
#: g10/import.c:437
#, c-format
msgid "key %08lX: 1 new signature\n"
msgstr "chave %08lX: 1 nova assinatura\n"
#: g10/import.c:440
#, c-format
msgid "key %08lX: %d new signatures\n"
msgstr "chave %08lX: %d novas assinaturas\n"
#: g10/import.c:443
#, c-format
msgid "key %08lX: 1 new subkey\n"
msgstr "chave %08lX: 1 nova subchave\n"
#: g10/import.c:446
#, c-format
msgid "key %08lX: %d new subkeys\n"
msgstr "chave %08lX: %d novas subchaves\n"
#: g10/import.c:456
#, c-format
msgid "key %08lX: not changed\n"
msgstr "chave %08lX: não modificada\n"
#: g10/import.c:535
#, c-format
msgid "can't lock secret keyring: %s\n"
msgstr "impossível bloquear anel de chaves secreto: %s\n"
#: g10/import.c:538
#, c-format
msgid "can't write keyring: %s\n"
msgstr "impossível escrever anel de chaves: %s\n"
#. we are ready
#: g10/import.c:541
#, c-format
msgid "key %08lX: secret key imported\n"
msgstr "chave %08lX: chave secreta importada\n"
#. we can't merge secret keys
#: g10/import.c:545
#, c-format
msgid "key %08lX: already in secret keyring\n"
msgstr "chave %08lX: já no anel de chaves secreto\n"
#: g10/import.c:550
#, c-format
msgid "key %08lX: secret key not found: %s\n"
msgstr "chave %08lX: chave secreta não encontrada: %s\n"
#: g10/import.c:579
#, c-format
msgid "key %08lX: no public key - can't apply revocation certificate\n"
msgstr ""
"chave %08lX: sem chave pública - impossível aplicar certificado\n"
"de revogação\n"
#: g10/import.c:612
#, c-format
msgid "key %08lX: invalid revocation certificate: %s - rejected\n"
msgstr "chave %08lX: certificado de revogação inválido: %s - rejeitado\n"
#: g10/import.c:646
#, c-format
msgid "key %08lX: revocation certificate imported\n"
msgstr "chave %08lX: certificado de revogação importado\n"
#: g10/import.c:677
#, c-format
msgid "key %08lX: no user-id for signature\n"
msgstr "chave %08lX: sem id de usuário para assinatura\n"
#: g10/import.c:684
#, c-format
msgid "key %08lX: unsupported public key algorithm\n"
msgstr "chave %08lX: algoritmo de chave pública não suportado\n"
#: g10/import.c:685
#, c-format
msgid "key %08lX: invalid self-signature\n"
msgstr "chave %08lX: auto-assinatura inválida\n"
#: g10/import.c:714
#, c-format
msgid "key %08lX: skipped userid '"
msgstr "chave %08lX: id de usuário ignorado '"
#: g10/import.c:737
#, c-format
msgid "key %08lX: revocation certificate at wrong place - skipped\n"
msgstr "chave %08lX: certificado de revogação no local errado - ignorado\n"
#: g10/import.c:745
#, c-format
msgid "key %08lX: invalid revocation certificate: %s - skipped\n"
msgstr "chave %08lX: certificado de revogação inválido: %s - ignorado\n"
#: g10/import.c:804
#, c-format
msgid "key %08lX: revocation certificate added\n"
msgstr "chave %08lX: certificado de revogação adicionado\n"
#: g10/import.c:918 g10/import.c:973
#, c-format
msgid "key %08lX: our copy has no self-signature\n"
msgstr "chave %08lX: nossa cópia não tem auto-assinatura\n"
#: g10/keyedit.c:81
#, c-format
msgid "%s: user not found\n"
msgstr "%s: usuário não encontrado\n"
#: g10/keyedit.c:164
msgid "[self-signature]"
msgstr "[auto-assinatura]"
#: g10/keyedit.c:182
msgid "1 bad signature\n"
msgstr "1 assinatura incorreta\n"
#: g10/keyedit.c:184
#, c-format
msgid "%d bad signatures\n"
msgstr "%d assinaturas incorretas\n"
#: g10/keyedit.c:186
msgid "1 signature not checked due to a missing key\n"
msgstr "1 assinatura não verificada por falta de chave\n"
#: g10/keyedit.c:188
#, c-format
msgid "%d signatures not checked due to missing keys\n"
msgstr "%d assinaturas não verificadas por falta de chaves\n"
#: g10/keyedit.c:190
msgid "1 signature not checked due to an error\n"
msgstr "1 assinatura não checada por causa de um erro\n"
#: g10/keyedit.c:192
#, c-format
msgid "%d signatures not checked due to errors\n"
msgstr "%d assinaturas não verificadas por causa de erros\n"
#: g10/keyedit.c:194
msgid "1 user id without valid self-signature detected\n"
msgstr "1 id de usuário sem auto-assinatura válida detectado\n"
#: g10/keyedit.c:196
#, c-format
msgid "%d user ids without valid self-signatures detected\n"
msgstr "%d ids de usuários sem auto-assinaturas válidas detectados\n"
#: g10/keyedit.c:258
#, c-format
msgid "Already signed by key %08lX\n"
msgstr "Já assinado pela chave %08lX\n"
#: g10/keyedit.c:266
#, c-format
msgid "Nothing to sign with key %08lX\n"
msgstr "Nada para assinar com a chave %08lX\n"
#: g10/keyedit.c:275
msgid ""
"Are you really sure that you want to sign this key\n"
"with your key: \""
msgstr ""
"Você tem certeza de que quer assinar esta chave com\n"
"sua chave: \""
#: g10/keyedit.c:282
msgid "Really sign? "
msgstr "Realmente assinar? "
#: g10/keyedit.c:303 g10/sign.c:65
#, c-format
msgid "signing failed: %s\n"
msgstr "assinatura falhou: %s\n"
#: g10/keyedit.c:356
msgid "This key is not protected.\n"
msgstr "Esta chave não é protegida.\n"
#: g10/keyedit.c:359
msgid "Key is protected.\n"
msgstr "A chave é protegida.\n"
#: g10/keyedit.c:376
#, c-format
msgid "Can't edit this key: %s\n"
msgstr "Impossível editar esta chave: %s\n"
#: g10/keyedit.c:381
msgid ""
"Enter the new passphrase for this secret key.\n"
"\n"
msgstr ""
"Digite a nova frase para esta chave secreta.\n"
"\n"
#: g10/keyedit.c:393
msgid ""
"You don't want a passphrase - this is probably a *bad* idea!\n"
"\n"
msgstr ""
"Você não quer uma frase secreta - provavelmente isto é uma *má* idéia!\n"
"\n"
#: g10/keyedit.c:396
msgid "Do you really want to do this? "
msgstr "Você realmente quer fazer isso? "
#: g10/keyedit.c:455
msgid "moving a key signature to the correct place\n"
msgstr "movendo a assinatura da chave para o local correto\n"
#: g10/keyedit.c:490
msgid "quit"
msgstr "sair"
#: g10/keyedit.c:490
msgid "quit this menu"
msgstr "sair deste menu"
#: g10/keyedit.c:491
msgid "q"
msgstr "s"
#: g10/keyedit.c:492
msgid "save"
msgstr "gravar"
#: g10/keyedit.c:492
msgid "save and quit"
msgstr "gravar e sair"
#: g10/keyedit.c:493
msgid "help"
msgstr "ajuda"
#: g10/keyedit.c:493
msgid "show this help"
msgstr "mostra esta ajuda"
#: g10/keyedit.c:495
msgid "fpr"
msgstr ""
#: g10/keyedit.c:495
msgid "show fingerprint"
msgstr "mostra impressão digital"
#: g10/keyedit.c:496
msgid "list"
msgstr "lista"
#: g10/keyedit.c:496
msgid "list key and user ids"
msgstr "lista chave e identificadores de usuários"
#: g10/keyedit.c:497
msgid "l"
msgstr ""
#: g10/keyedit.c:498
msgid "uid"
msgstr ""
#: g10/keyedit.c:498
msgid "select user id N"
msgstr "seleciona id de usuário N"
#: g10/keyedit.c:499
msgid "key"
msgstr "chave"
#: g10/keyedit.c:499
msgid "select secondary key N"
msgstr "seleciona chave secundária N"
#: g10/keyedit.c:500
msgid "check"
msgstr "verifica"
#: g10/keyedit.c:500
msgid "list signatures"
msgstr "lista assinaturas"
#: g10/keyedit.c:501
msgid "c"
msgstr "v"
#: g10/keyedit.c:502
msgid "sign"
msgstr "assina"
#: g10/keyedit.c:502
msgid "sign the key"
msgstr "assina a chave"
#: g10/keyedit.c:503
msgid "s"
msgstr "a"
#: g10/keyedit.c:504
msgid "debug"
msgstr "depura"
#: g10/keyedit.c:505
msgid "adduid"
msgstr ""
#: g10/keyedit.c:505
msgid "add a user id"
msgstr "adiciona um novo id de usuário"
#: g10/keyedit.c:506
msgid "deluid"
msgstr ""
#: g10/keyedit.c:506
msgid "delete user id"
msgstr "deleta id de usuário"
#: g10/keyedit.c:507
msgid "addkey"
msgstr ""
#: g10/keyedit.c:507
msgid "add a secondary key"
msgstr "adiciona nova chave secundária"
#: g10/keyedit.c:508
msgid "delkey"
msgstr ""
#: g10/keyedit.c:508
msgid "delete a secondary key"
msgstr "deleta uma chave secundária"
#: g10/keyedit.c:509
msgid "expire"
msgstr "expira"
#: g10/keyedit.c:509
msgid "change the expire date"
msgstr "muda a data em que a chave expira"
#: g10/keyedit.c:510
msgid "toggle"
msgstr "comuta"
#: g10/keyedit.c:510
msgid "toggle between secret and public key listing"
msgstr "comuta entre listagem de chave secreta e pública"
#: g10/keyedit.c:512
msgid "t"
msgstr "c"
#: g10/keyedit.c:513
msgid "pref"
msgstr ""
#: g10/keyedit.c:513
msgid "list preferences"
msgstr "lista preferências"
#: g10/keyedit.c:514
msgid "passwd"
msgstr "senha"
#: g10/keyedit.c:514
msgid "change the passphrase"
msgstr "muda a frase secreta"
#: g10/keyedit.c:515
msgid "trust"
msgstr "confianca"
#: g10/keyedit.c:515
msgid "change the ownertrust"
msgstr "muda os valores de confiança"
#: g10/keyedit.c:534
msgid "can't do that in batchmode\n"
msgstr "impossível fazer isso em modo de processo por lotes\n"
#. check that they match
#. FIXME: check that they both match
#: g10/keyedit.c:561
msgid "Secret key is available.\n"
msgstr "Chave secreta disponível\n"
#: g10/keyedit.c:590
msgid "Command> "
msgstr "Comando> "
#: g10/keyedit.c:617
#, fuzzy
msgid "Need the secret key to do this.\n"
msgstr "A chave secreta é necessária para fazer isto.\n"
#: g10/keyedit.c:639
msgid "Save changes? "
msgstr "Salvar alterações? "
#: g10/keyedit.c:642
msgid "Quit without saving? "
msgstr "Sair sem salvar? "
#: g10/keyedit.c:652
#, c-format
msgid "update failed: %s\n"
msgstr "atualização falhou: %s\n"
#: g10/keyedit.c:659
#, c-format
msgid "update secret failed: %s\n"
msgstr "atualização da chave secreta falhou: %s\n"
#: g10/keyedit.c:666
msgid "Key not changed so no update needed.\n"
msgstr "Chave sem mudanças, nenhuma atualização é necessária.\n"
#: g10/keyedit.c:669 g10/keyedit.c:727
#, c-format
msgid "update of trust db failed: %s\n"
msgstr "atualização da confiança falhou: %s\n"
#: g10/keyedit.c:701
msgid "Really sign all user ids? "
msgstr "Realmente assinar todos os ids de usuário? "
#: g10/keyedit.c:702
msgid "Hint: Select the user ids to sign\n"
msgstr "Sugestão: Selecione os ids de usuário para assinar\n"
#: g10/keyedit.c:738
msgid "You must select at least one user id.\n"
msgstr "Você precisa selecionar pelo menos um id de usuário.\n"
#: g10/keyedit.c:740
msgid "You can't delete the last user id!\n"
msgstr "Você não pode deletar o último id de usuário!\n"
#: g10/keyedit.c:743
msgid "Really remove all selected user ids? "
msgstr "Realmente remover todos os ids de usuário selecionados? "
#: g10/keyedit.c:744
msgid "Really remove this user id? "
msgstr "Realmente remover este id de usuário? "
#: g10/keyedit.c:767
msgid "You must select at least one key.\n"
msgstr "Você deve selecionar pelo menos uma chave.\n"
#: g10/keyedit.c:771
msgid "Do you really want to delete the selected keys? "
msgstr "Você realmente quer deletar as chaves selecionadas? "
#: g10/keyedit.c:772
msgid "Do you really want to delete this key? "
msgstr "Você realmente quer deletar esta chave? "
#: g10/keyedit.c:819
msgid "Invalid command (try \"help\")\n"
msgstr "Comando inválido (tente \"ajuda\")\n"
#: g10/keyedit.c:1197
msgid "Please remove selections from the secret keys.\n"
msgstr "Por favor remova as seleções das chaves secretas.\n"
#: g10/keyedit.c:1203
msgid "Please select at most one secondary key.\n"
msgstr "Por favor selecione no máximo uma chave secundária.\n"
#: g10/keyedit.c:1207
msgid "Changing exiration time for a secondary key.\n"
msgstr "Modificando data de expiração para a chave secundária.\n"
#: g10/keyedit.c:1209
msgid "Changing exiration time for the primary key.\n"
msgstr "Modificando data de expiração para a chave primária.\n"
#: g10/keyedit.c:1250
msgid "You can't change the expiration date of a v3 key\n"
msgstr "Você não pode modificar a data de expiração de uma chave v3\n"
#: g10/keyedit.c:1266
msgid "No corresponding signature in secret ring\n"
msgstr "Nenhuma assinatura correspondente no anel de chaves secreto\n"
#: g10/keyedit.c:1326
#, c-format
msgid "No user id with index %d\n"
msgstr "Nenhum id de usuário com índice %d\n"
#: g10/keyedit.c:1371
#, c-format
msgid "No secondary key with index %d\n"
msgstr "Nenhuma chave secundária com índice %d\n"
#: g10/mainproc.c:198
#, fuzzy
msgid "public key encrypted data: Good DEK\n"
msgstr "dados codificados com chave pública: DEK bom\n"
#: g10/mainproc.c:201
#, c-format
msgid "public key decryption failed: %s\n"
msgstr "decodificação de chave pública falhou: %s\n"
#: g10/mainproc.c:228
msgid "decryption okay\n"
msgstr "decodificação correta\n"
#: g10/mainproc.c:231
#, c-format
msgid "decryption failed: %s\n"
msgstr "decodifiação falhou: %s\n"
#: g10/mainproc.c:248
msgid "NOTE: sender requested \"for-your-eyes-only\"\n"
msgstr "NOTA: o remetente solicitou \"apenas-para-seus-olhos\"\n"
#: g10/mainproc.c:250
#, c-format
msgid "original file name='%.*s'\n"
msgstr "nome de arquivo original='%.*s'\n"
#: g10/mainproc.c:833
msgid "signature verification suppressed\n"
msgstr "verifiação de assinatura suprimida\n"
#: g10/mainproc.c:839
#, c-format
msgid "Signature made %.*s using %s key ID %08lX\n"
msgstr "Assinatura feita %.*s usando %s ID da chave %08lX\n"
#: g10/mainproc.c:847
msgid "BAD signature from \""
msgstr "Assinatura INCORRETA de \""
#: g10/mainproc.c:848
msgid "Good signature from \""
msgstr "Assinatura correta de\""
#: g10/mainproc.c:861
#, c-format
msgid "Can't check signature: %s\n"
msgstr "Impossível verificar assinatura: %s\n"
#: g10/mainproc.c:934
msgid "old style (PGP 2.x) signature\n"
msgstr "assinatura antiga (PGP2.x)\n"
#: g10/mainproc.c:939
msgid "invalid root packet detected in proc_tree()\n"
msgstr "pacote raiz inválido detectado em proc_tree()\n"
#: g10/misc.c:88
#, c-format
msgid "can't disable core dumps: %s\n"
msgstr "impossível desabilitar core dumps: %s\n"
#: g10/misc.c:90
msgid "WARNING: Program may create a core file!\n"
msgstr "AVISO: O programa pode criar um arquivo core!\n"
#: g10/misc.c:198
msgid "Experimental algorithms should not be used!\n"
msgstr ""
#: g10/misc.c:212
msgid ""
"RSA keys are deprecated; please consider creating a new key and use this key "
"in the future\n"
msgstr ""
"Chaves RSA não são recomendáveis; por favor considere criar uma nova chave e "
"usá-la no futuro\n"
#: g10/misc.c:233
msgid "This cipher algorithm is depreciated; please use a more standard one!\n"
msgstr ""
#: g10/parse-packet.c:109
#, c-format
msgid "can't handle public key algorithm %d\n"
msgstr "impossível manipular algoritmo de chave pública %d\n"
#: g10/passphrase.c:141
msgid ""
"\n"
"You need a passphrase to unlock the secret key for\n"
"user: \""
msgstr ""
"\n"
"Você precisa de uma frase para desbloquear a chave secreta do\n"
"usuário: \""
#: g10/passphrase.c:150
#, c-format
msgid "(%u-bit %s key, ID %08lX, created %s)\n"
msgstr "(chave %u-bit/%s, ID %08lX, criada em %s)\n"
#: g10/passphrase.c:174
msgid "Enter passphrase: "
msgstr "Digite a frase secreta: "
#: g10/passphrase.c:178
msgid "Repeat passphrase: "
msgstr "Repita a frase secreta: "
#: g10/plaintext.c:102
msgid "data not saved; use option \"--output\" to save it\n"
msgstr "dados não salvos; use a opção \"--output\" para salvá-los\n"
#: g10/plaintext.c:215
msgid "Please enter name of data file: "
msgstr "Por favor digite o nome do arquivo de dados: "
#: g10/plaintext.c:236
msgid "reading stdin ...\n"
msgstr "lendo \"stdin\" ...\n"
#: g10/plaintext.c:299
#, c-format
msgid "can't open signed data '%s'\n"
msgstr "impossível abrir dados assinados '%s'\n"
#: g10/pubkey-enc.c:78
#, c-format
msgid "anonymous receiver; trying secret key %08lX ...\n"
msgstr "destinatário anônimo; tentando chave secreta %08lX ...\n"
#: g10/pubkey-enc.c:84
msgid "okay, we are the anonymous receiver.\n"
msgstr "correto, nós somos o destinatário anônimo.\n"
#: g10/pubkey-enc.c:136
msgid "old encoding of the DEK is not supported\n"
msgstr "codificação antiga do DEK não suportada\n"
#: g10/pubkey-enc.c:183
#, c-format
msgid "NOTE: cipher algorithm %d not found in preferences\n"
msgstr "NOTA: algoritmo de criptografia %d não encontrado nas preferências\n"
#: g10/seckey-cert.c:56
#, c-format
msgid "protection algorithm %d is not supported\n"
msgstr "algoritmo de proteção %d não é suportado\n"
#: g10/seckey-cert.c:169
msgid "Invalid passphrase; please try again ...\n"
msgstr "Frase secreta inválida; por favor tente novamente ...\n"
#: g10/seckey-cert.c:216
msgid "WARNING: Weak key detected - please change passphrase again.\n"
msgstr ""
"AVISO: Chave fraca detectada - por favor mude a frase secreta novamente\n"
#: g10/sig-check.c:155
msgid ""
"this is a PGP generated ElGamal key which is NOT secure for signatures!\n"
msgstr ""
"esta é uma chave ElGamal gerada pelo PGP que NÃO é segura para assinaturas!\n"
#: g10/sig-check.c:165
msgid "public key created in future (time warp or clock problem)\n"
msgstr ""
"chave pública criada no futuro (viagem no tempo ou problema no relógio)\n"
#: g10/sig-check.c:170
#, c-format
msgid "NOTE: signature key expired %s\n"
msgstr "NOTA: chave de assinatura expirou %s\n"
#: g10/sign.c:69
#, c-format
msgid "%s signature from: %s\n"
msgstr "%s assinatura de: %s\n"
#: g10/sign.c:200 g10/sign.c:564
#, c-format
msgid "can't create %s: %s\n"
msgstr "impossível criar %s: %s\n"
#: g10/sign.c:296
msgid "signing:"
msgstr "assinando:"
#: g10/sign.c:336
#, c-format
msgid "WARNING: '%s' is an empty file\n"
msgstr "AVISO: '%s' é um arquivo vazio\n"
#: g10/tdbio.c:116 g10/tdbio.c:1413
#, fuzzy, c-format
msgid "trustdb rec %lu: lseek failed: %s\n"
msgstr "banco de dados de confiança rec %lu: lseek falhou: %s\n"
#: g10/tdbio.c:122 g10/tdbio.c:1420
#, fuzzy, c-format
msgid "trustdb rec %lu: write failed (n=%d): %s\n"
msgstr "banco de dados de confiança rec %lu: escrita falhou (n=%d): %s\n"
#: g10/tdbio.c:232
msgid "trustdb transaction to large\n"
msgstr "transação de banco de dados de confiança muito grande\n"
#: g10/tdbio.c:402
#, c-format
msgid "%s: can't access: %s\n"
msgstr "%s: impossível acessar: %s\n"
#: g10/ringedit.c:273 g10/tdbio.c:422
#, c-format
msgid "%s: can't create directory: %s\n"
msgstr "%s: impossível criar diretório: %s\n"
#: g10/ringedit.c:279 g10/tdbio.c:425
#, c-format
msgid "%s: directory created\n"
msgstr "%s: diretório criado\n"
#: g10/tdbio.c:429
#, c-format
msgid "%s: directory does not exist!\n"
msgstr "%s: diretório inexistente!\n"
#: g10/openfile.c:101 g10/openfile.c:165 g10/ringedit.c:1256 g10/tdbio.c:435
#, c-format
msgid "%s: can't create: %s\n"
msgstr "%s: impossível criar: %s\n"
#: g10/tdbio.c:459
#, c-format
msgid "%s: failed to create version record: %s"
msgstr "%s: falha ao criar registro de versão: %s"
#: g10/tdbio.c:463
#, c-format
msgid "%s: invalid trust-db created\n"
msgstr "%s: banco de dados de confiança inválido criado\n"
#: g10/tdbio.c:465
#, c-format
msgid "%s: trust-db created\n"
msgstr "%s: banco de dados de confiança criado\n"
#: g10/tdbio.c:506
#, c-format
msgid "%s: invalid trust-db\n"
msgstr "%s: banco de dados de confiança inválido\n"
#: g10/tdbio.c:540
#, c-format
msgid "%s: failed to create hashtable: %s\n"
msgstr "%s: falha ao criar tabela \"hash\": %s\n"
#: g10/tdbio.c:548
#, c-format
msgid "%s: error updating version record: %s\n"
msgstr "%s: erro atualizando registro de versão: %s\n"
#: g10/tdbio.c:564 g10/tdbio.c:603 g10/tdbio.c:628 g10/tdbio.c:1346
#: g10/tdbio.c:1373
#, c-format
msgid "%s: error reading version record: %s\n"
msgstr "%s: erro lendo registro de versão: %s\n"
#: g10/tdbio.c:577
#, c-format
msgid "%s: error writing version record: %s\n"
msgstr "%s: erro escrevendo registro de versão: %s\n"
#: g10/tdbio.c:1053
#, c-format
msgid "trustdb: lseek failed: %s\n"
msgstr "banco de dados de confiança: lseek falhou: %s\n"
#: g10/tdbio.c:1061
#, c-format
msgid "trustdb: read failed (n=%d): %s\n"
msgstr "banco de dados de confiança: leitura falhou (n=%d): %s\n"
#: g10/tdbio.c:1082
#, c-format
msgid "%s: not a trustdb file\n"
msgstr "%s: não é um banco de dados de confiança\n"
#: g10/tdbio.c:1098
#, c-format
msgid "%s: version record with recnum %lu\n"
msgstr "%s: registro de versão com recnum %lu\n"
#: g10/tdbio.c:1103
#, c-format
msgid "%s: invalid file version %d\n"
msgstr "%s: versão de arquivo inválida %d\n"
#: g10/tdbio.c:1379
#, c-format
msgid "%s: error reading free record: %s\n"
msgstr "%s: erro lendo registro livre: %s\n"
#: g10/tdbio.c:1387
#, fuzzy, c-format
msgid "%s: error writing dir record: %s\n"
msgstr "%s: erro escrevendo registro de diretório: %s\n"
#: g10/tdbio.c:1397
#, c-format
msgid "%s: failed to zero a record: %s\n"
msgstr "%s: falha ao zerar um registro: %s\n"
#: g10/tdbio.c:1427
#, c-format
msgid "%s: failed to append a record: %s\n"
msgstr "%s: falha ao anexar um registro: %s\n"
#: g10/trustdb.c:134
msgid "The trust DB is corrupted; please run \"gpgm --fix-trust-db\".\n"
msgstr ""
"O banco de dados de confiança está danificado; por favor rode\n"
"\"gpgm --fix-trust-db\".\n"
#: g10/trustdb.c:147
#, fuzzy, c-format
msgid "trust record %lu, req type %d: read failed: %s\n"
msgstr "registro de confiança %lu, tipo req %d: leitura falhou: %s\n"
#: g10/trustdb.c:162
#, c-format
msgid "trust record %lu, type %d: write failed: %s\n"
msgstr "registro de confiança %lu, tipo %d: gravação falhou: %s\n"
#: g10/trustdb.c:176
#, c-format
msgid "trust record %lu: delete failed: %s\n"
msgstr "registro de confiança %lu: remoção falhou: %s\n"
#: g10/trustdb.c:190
#, c-format
msgid "trust db: sync failed: %s\n"
msgstr "banco de dados de confiança: sincronização falhou: %s\n"
#: g10/trustdb.c:319
#, fuzzy, c-format
msgid "error reading dir record for LID %lu: %s\n"
msgstr "erro lendo registro de diretório para LID %lu: %s\n"
#: g10/trustdb.c:326
#, fuzzy, c-format
msgid "lid %lu: expected dir record, got type %d\n"
msgstr "lid %lu: registro de diretório esperado, tipo %d recebido\n"
#: g10/trustdb.c:331
#, c-format
msgid "no primary key for LID %lu\n"
msgstr "nenhuma chave primária para LID %lu\n"
#: g10/trustdb.c:336
#, c-format
msgid "error reading primary key for LID %lu: %s\n"
msgstr "erro lendo chave primária para LID %lu: %s\n"
#: g10/trustdb.c:412
#, fuzzy, c-format
msgid "chained sigrec %lu has a wrong owner\n"
msgstr "sigrec em cadeia %lu possui dono errado\n"
#: g10/trustdb.c:455
#, fuzzy, c-format
msgid "'%s' is not a valid long keyID\n"
msgstr "%s não é um mapa de caracteres válido\n"
#: g10/trustdb.c:490
#, fuzzy, c-format
msgid "key %08lX: no public key for trusted key - skipped\n"
msgstr "chave %08lX: chave secreta sem chave pública - ignorada\n"
#: g10/trustdb.c:499 g10/trustdb.c:557
#, c-format
msgid "key %08lX: can't put it into the trustdb\n"
msgstr "chave %08lX: impossível colocá-la no banco de dados de confiança\n"
#: g10/trustdb.c:504 g10/trustdb.c:563
#, c-format
msgid "key %08lX: query record failed\n"
msgstr "chave %08lX: pedido de registro falhou\n"
#: g10/trustdb.c:509 g10/trustdb.c:572
#, fuzzy, c-format
msgid "key %08lX: already in trusted key table\n"
msgstr "chave %08lX: já está na tabela de chaves secretas\n"
#: g10/trustdb.c:512 g10/trustdb.c:575
#, fuzzy, c-format
msgid "key %08lX: accepted as trusted key.\n"
msgstr "chave %08lX: aceita como chave secreta.\n"
#: g10/trustdb.c:528
#, c-format
msgid "NOTE: secret key %08lX is NOT protected.\n"
msgstr "NOTA: chave secreta %08lX NÃO está protegida.\n"
#: g10/trustdb.c:540
#, c-format
msgid "key %08lX: secret key without public key - skipped\n"
msgstr "chave %08lX: chave secreta sem chave pública - ignorada\n"
#: g10/trustdb.c:547
#, c-format
msgid "key %08lX: secret and public key don't match\n"
msgstr "chave %08lX: chaves secreta e pública não combinam\n"
#: g10/trustdb.c:583
#, c-format
msgid "enumerate secret keys failed: %s\n"
msgstr "enumeração de chaves secretas falhou: %s\n"
#: g10/trustdb.c:766
#, fuzzy, c-format
msgid "lid %lu: read dir record failed: %s\n"
msgstr "lid %lu: leitura de registro de diretório falhou: %s\n"
#: g10/trustdb.c:775
#, c-format
msgid "lid %lu: read key record failed: %s\n"
msgstr "lid %lu: leitura de registro de chave falhou: %s\n"
#: g10/trustdb.c:785
#, c-format
msgid "lid %lu: read uid record failed: %s\n"
msgstr "lid %lu: leitura de registro de uid falhou: %s\n"
#: g10/trustdb.c:794
#, fuzzy, c-format
msgid "lid %lu: read pref record failed: %s\n"
msgstr "lid %lu: leitura de registro de preferências falhou: %s\n"
#: g10/trustdb.c:804
#, c-format
msgid "lid %lu: read sig record failed: %s\n"
msgstr "lid %lu: leitura de registro de assinatura falhou: %s\n"
#: g10/trustdb.c:999
msgid "Ooops, no keys\n"
msgstr "Ooops, nenhuma chave\n"
#: g10/trustdb.c:1003
msgid "Ooops, no user ids\n"
msgstr "Ooops, nenhum id de usuário\n"
#: g10/trustdb.c:1074 g10/trustdb.c:1092
#, c-format
msgid "user '%s' read problem: %s\n"
msgstr "erro de leitura do usuário '%s': %s\n"
#: g10/trustdb.c:1077 g10/trustdb.c:1095
#, c-format
msgid "user '%s' list problem: %s\n"
msgstr "erro de listagem do usuário '%s': %s\n"
#: g10/trustdb.c:1085 g10/trustdb.c:1300
#, c-format
msgid "user '%s' not found: %s\n"
msgstr "usuário '%s' não encontrado: %s\n"
#: g10/trustdb.c:1087 g10/trustdb.c:1302
#, c-format
msgid "problem finding '%s' in trustdb: %s\n"
msgstr "problemas encontrando '%s' no banco de dados de confiança: %s\n"
#: g10/trustdb.c:1090
#, c-format
msgid "user '%s' not in trustdb\n"
msgstr "usuário '%s' não está no banco de dados de confiança\n"
#: g10/trustdb.c:1125
#, c-format
msgid ""
"# List of assigned trustvalues, created %s\n"
"# (Use \"gpgm --import-ownertrust\" to restore them)\n"
msgstr ""
"# Lista de valores de confiança designados, criada em %s\n"
"# (Use \"gpgm --import-ownertrust\" para restaurá-los)\n"
#: g10/trustdb.c:1131
msgid "directory record w/o primary key\n"
msgstr "registro de diretório sem chave primária\n"
#: g10/trustdb.c:1138
#, c-format
msgid "error reading key record: %s\n"
msgstr "erro lendo registro de chave: %s\n"
#: g10/trustdb.c:1178
-msgid "line to long\n"
+msgid "line too long\n"
msgstr "linha muito longa\n"
#: g10/trustdb.c:1186
msgid "error: missing colon\n"
msgstr "erro: falta dois pontos\n"
#: g10/trustdb.c:1191
msgid "error: invalid fingerprint\n"
msgstr "erro: impressão digital inválida\n"
#: g10/trustdb.c:1195
msgid "error: no ownertrust value\n"
msgstr "erro: nenhum valor de confiança\n"
#: g10/trustdb.c:1209
#, c-format
msgid "LID %lu: changing trust from %u to %u\n"
msgstr "LID %lu: mudando confiança de %u para %u\n"
#: g10/trustdb.c:1212
#, c-format
msgid "LID %lu: setting trust to %u\n"
msgstr "LID %lu: estabelecendo confiança para %u\n"
#: g10/trustdb.c:1220
msgid "key not in trustdb, searching ring.\n"
msgstr ""
"chave não encontrada no banco de dados de confiança, procurando no anel\n"
#: g10/trustdb.c:1223
#, c-format
msgid "key not in ring: %s\n"
msgstr "chave não encontrada no anel: %s\n"
#: g10/trustdb.c:1227
msgid "Oops: key is now in trustdb???\n"
msgstr "Oops: agora a chave está no banco de dados de confiança???\n"
#. update the ownertrust
#: g10/trustdb.c:1232
#, c-format
msgid "insert trust record failed: %s\n"
msgstr "inserção de registro de confiança falhou: %s\n"
#. error
#: g10/trustdb.c:1238
#, fuzzy, c-format
msgid "error finding dir record: %s\n"
msgstr "erro encontrando registro de diretório: %s\n"
#: g10/trustdb.c:1305
#, c-format
msgid "user '%s' not in trustdb - inserting\n"
msgstr ""
"usuário '%s' não encontrado no banco de dados de confiança - inserindo\n"
#: g10/trustdb.c:1308
#, c-format
msgid "failed to put '%s' into trustdb: %s\n"
msgstr "falha ao colocar '%s' no banco de dados de confiança: %s\n"
#: g10/trustdb.c:1355
#, c-format
msgid "%s: keyblock read problem: %s\n"
msgstr "%s: erro de leitura de bloco de chaves: %s\n"
#: g10/trustdb.c:1369
#, c-format
msgid "%s: update failed: %s\n"
msgstr "%s: atualização falhou: %s\n"
#: g10/trustdb.c:1372
#, c-format
msgid "%s: updated\n"
msgstr "%s: atualizado\n"
#: g10/trustdb.c:1374
#, c-format
msgid "%s: okay\n"
msgstr "%s: correto\n"
#: g10/trustdb.c:1389
#, fuzzy, c-format
msgid "lid %lu: dir record w/o key - skipped\n"
msgstr "lid %lu: registro de diretório sem chave - ignorado\n"
#: g10/trustdb.c:1402
#, c-format
msgid "lid %lu: keyblock not found: %s\n"
msgstr "lid %lu: bloco de chaves não encontrado: %s\n"
#: g10/trustdb.c:1411 g10/trustdb.c:1480
#, c-format
msgid "lid %lu: update failed: %s\n"
msgstr "lid %lu: atualização falhou %s\n"
#: g10/trustdb.c:1417 g10/trustdb.c:1486
#, c-format
msgid "lid %lu: updated\n"
msgstr "lid %lu: atualizado\n"
#: g10/trustdb.c:1421 g10/trustdb.c:1490
#, c-format
msgid "lid %lu: okay\n"
msgstr "lid %lu: correto\n"
#: g10/trustdb.c:1428 g10/trustdb.c:1496
#, c-format
msgid "%lu keys processed\n"
msgstr "%lu chaves processadas\n"
#: g10/trustdb.c:1430
#, c-format
msgid "\t%lu keys skipped\n"
msgstr "\t%lu chaves ignoradas\n"
#: g10/trustdb.c:1432 g10/trustdb.c:1498
#, c-format
msgid "\t%lu keys with errors\n"
msgstr "\t%lu chaves com erros\n"
#: g10/trustdb.c:1434 g10/trustdb.c:1500
#, c-format
msgid "\t%lu keys updated\n"
msgstr "\t%lu chaves atualizadas\n"
#: g10/trustdb.c:1464
#, c-format
msgid "lid ?: insert failed: %s\n"
msgstr "lid ?: inserção falhou: %s\n"
#: g10/trustdb.c:1469
#, c-format
msgid "lid %lu: insert failed: %s\n"
msgstr "lid %lu: inserção falhou: %s\n"
#: g10/trustdb.c:1475
#, c-format
msgid "lid %lu: inserted\n"
msgstr "lid %lu: inserido\n"
#: g10/trustdb.c:1502
#, c-format
msgid "\t%lu keys inserted\n"
msgstr "\t%lu chaves inseridas\n"
#: g10/trustdb.c:1505
#, c-format
msgid "enumerate keyblocks failed: %s\n"
msgstr "enumeração de blocos de chaves falhou: %s\n"
#: g10/trustdb.c:1550
#, c-format
msgid "check_trust: search dir record failed: %s\n"
msgstr "check_trust: busca de registro de diretório falhou: %s\n"
#: g10/trustdb.c:1557
#, c-format
msgid "key %08lX: insert trust record failed: %s\n"
msgstr "chave %08lX: inserção de registro de confiança falhou: %s\n"
#: g10/trustdb.c:1561
#, c-format
msgid "key %08lX.%lu: inserted into trustdb\n"
msgstr "chave %08lX.%lu: inserida no banco de dados de confiança\n"
#: g10/trustdb.c:1569
#, c-format
msgid "key %08lX.%lu: created in future (time warp or clock problem)\n"
msgstr ""
"chave %08lX.%lu: criada no futuro (viagem no tempo ou problema no relogio)\n"
#: g10/trustdb.c:1576
#, c-format
msgid "key %08lX.%lu: expired at %s\n"
msgstr "chave %08lX.%lu: expirada em %s\n"
#: g10/trustdb.c:1584
#, c-format
msgid "key %08lX.%lu: trust check failed: %s\n"
msgstr "chave %08lX.%lu: verificação de confiança falhou: %s\n"
#: g10/trustdb.c:1753 g10/trustdb.c:1782 g10/trustdb.c:2521
msgid "WARNING: can't yet handle long pref records\n"
msgstr "AVISO: ainda é impossível manipular registros de preferências longos\n"
#: g10/trustdb.c:1804
#, c-format
msgid "get_dir_record: search_record failed: %s\n"
msgstr "get_dir_record: search_record falhou: %s\n"
#: g10/trustdb.c:1867
#, fuzzy, c-format
msgid "NOTE: sig rec %lu[%d] in hintlist of %lu but marked as checked\n"
msgstr ""
"NOTA: assinatura rec %lu[%d] em lista de sugestões de %lu mas marcada\n"
"como verificada\n"
#: g10/trustdb.c:1871
#, fuzzy, c-format
msgid "NOTE: sig rec %lu[%d] in hintlist of %lu but not marked\n"
msgstr ""
"NOTA: assinatura rec %lu[%d] em lista de sugestões de %lu mas não\n"
"marcada\n"
#. we need the dir record
#: g10/trustdb.c:1878
#, c-format
msgid "sig rec %lu[%d] in hintlist of %lu does not point to a dir record\n"
msgstr ""
"assinatura rec %lu[%d] em lista de sugestões de %lu não aponta para\n"
"um registro de diretório\n"
#: g10/trustdb.c:1884
#, c-format
msgid "lid %lu: no primary key\n"
msgstr "lid %lu: nenhuma chave primária\n"
#: g10/trustdb.c:1917
#, c-format
msgid "lid %lu: user id not found in keyblock\n"
msgstr "lid %lu: id de usuário não encontrado no bloco de chaves\n"
#: g10/trustdb.c:1921
#, c-format
msgid "lid %lu: user id without signature\n"
msgstr "lid %lu: id de usuário sem assinatura\n"
#: g10/trustdb.c:1928
#, c-format
msgid "lid %lu: self-signature in hintlist\n"
msgstr "lid %lu: auto-assinatura na lista de sugestões\n"
#: g10/trustdb.c:1939 g10/trustdb.c:2658 g10/trustdb.c:2742
msgid "Valid certificate revocation"
msgstr "Certificado de revogação válido"
#: g10/trustdb.c:1940 g10/trustdb.c:2659 g10/trustdb.c:2743
msgid "Good certificate"
msgstr "Certificado correto"
#: g10/trustdb.c:1949
msgid "very strange: no public key\n"
msgstr "muito estranho: nenhuma chave pública\n"
#: g10/trustdb.c:1997
#, c-format
msgid "hintlist %lu[%d] of %lu does not point to a dir record\n"
msgstr ""
"lista de sugestões %lu[%d] de %lu não aponta para registro de diretório\n"
#: g10/trustdb.c:2003
#, c-format
msgid "lid %lu does not have a key\n"
msgstr "lid %lu não tem uma chave\n"
#: g10/trustdb.c:2013
#, c-format
msgid "lid %lu: can't get keyblock: %s\n"
msgstr "lid %lu: impossível pegar bloco de chaves: %s\n"
#: g10/trustdb.c:2070 g10/trustdb.c:2984
#, c-format
msgid "tdbio_search_dir failed: %s\n"
msgstr "tdbio_search_dir falhou: %s\n"
#: g10/trustdb.c:2223
#, c-format
msgid "key %08lX.%lu: Good subkey binding\n"
msgstr "chave %08lX.%lu: Ligação de subchave válida\n"
#: g10/trustdb.c:2229 g10/trustdb.c:2271
#, c-format
msgid "key %08lX.%lu: Invalid subkey binding: %s\n"
msgstr "chave %08lX.%lu: Ligação de subchave inválida: %s\n"
#: g10/trustdb.c:2244
#, c-format
msgid "key %08lX.%lu: Valid key revocation\n"
msgstr "chave %08lX.%lu: Revogação de chave válida\n"
#: g10/trustdb.c:2250
#, c-format
msgid "key %08lX.%lu: Invalid key revocation: %s\n"
msgstr "chave %08lX.%lu: Revogação de chave inválida: %s\n"
#: g10/trustdb.c:2265
#, c-format
msgid "key %08lX.%lu: Valid subkey revocation\n"
msgstr "chave %08lX.%lu: Revogação de subchave válida\n"
#: g10/trustdb.c:2365
msgid "Good self-signature"
msgstr "Auto-assinatura válida"
#: g10/trustdb.c:2376
msgid "Invalid self-signature"
msgstr "Auto-assinatura inválida"
#: g10/trustdb.c:2386
msgid "Valid user ID revocation skipped due to a newer self signature\n"
msgstr ""
#: g10/trustdb.c:2393
msgid "Valid user ID revocation\n"
msgstr "Revogação de ID de usuário válida\n"
#: g10/trustdb.c:2400
msgid "Invalid user ID revocation"
msgstr "Revogação de ID de usuário inválida"
#: g10/trustdb.c:2484
msgid "Too many preferences"
msgstr "Muitas preferências"
#: g10/trustdb.c:2498
msgid "Too many preference items"
msgstr "Muitos itens de preferência"
#: g10/trustdb.c:2637
msgid "Duplicated certificate - deleted"
msgstr "Certificado duplicado - deletado"
#: g10/trustdb.c:2670
msgid "Hmmm, public key lost?"
msgstr "Hmmm, chave pública perdida?"
#: g10/trustdb.c:2680 g10/trustdb.c:2763
msgid "Invalid certificate revocation"
msgstr "Certificado de revogação inválido"
#: g10/trustdb.c:2681 g10/trustdb.c:2764
msgid "Invalid certificate"
msgstr "Certificado inválido"
#: g10/trustdb.c:2696
#, c-format
msgid "uid %08lX.%lu/%02X%02X: has shadow dir %lu but is not yet marked.\n"
msgstr ""
"uid %08lX.%lu/%02X%02X: tem diretório sombra %lu mas ainda não está\n"
"marcado\n"
#: g10/trustdb.c:2710
#, c-format
msgid "sig record %lu[%d] points to wrong record.\n"
msgstr "registro de assinatura %lu[%d] aponta para registro errado.\n"
#. that should never happen
#: g10/trustdb.c:2954
#, c-format
msgid "insert_trust_record: keyblock not found: %s\n"
msgstr "insert_trust_record: bloco de chaves não encontrado: %s\n"
#: g10/trustdb.c:2972
msgid "did not use primary key for insert_trust_record()\n"
msgstr "você usou a chave primária para insert_trust_record()\n"
#: g10/ringedit.c:293
#, c-format
msgid "%s: can't create keyring: %s\n"
msgstr "%s: impossível criar anel de chaves: %s\n"
#: g10/ringedit.c:299 g10/ringedit.c:1264
#, c-format
msgid "%s: keyring created\n"
msgstr "%s: anel de chaves criado\n"
#: g10/ringedit.c:1449
msgid "WARNING: 2 files with confidential information exists.\n"
msgstr "AVISO: 2 arquivos com informações confidenciais existem.\n"
#: g10/ringedit.c:1450
#, c-format
msgid "%s is the unchanged one\n"
msgstr "%s é o não modificado\n"
#: g10/ringedit.c:1451
#, c-format
msgid "%s is the new one\n"
msgstr "%s é o novo\n"
#: g10/ringedit.c:1452
msgid "Please fix this possible security flaw\n"
msgstr "Por favor conserte este possível furo de segurança\n"
#: g10/skclist.c:94
#, c-format
msgid "skipped '%s': %s\n"
msgstr "ignorado '%s': %s\n"
#: g10/skclist.c:100
#, c-format
msgid ""
"skipped '%s': this is a PGP generated ElGamal key which is not secure for "
"signatures!\n"
msgstr ""
"ignorado '%s': esta é uma chave ElGamal gerada pelo PGP que não é segura "
"para assinaturas!\n"
#. do not overwrite
#: g10/openfile.c:58
#, c-format
msgid "File '%s' exists. "
msgstr "Arquivo '%s' existe. "
#: g10/openfile.c:60
msgid "Overwrite (y/N)? "
msgstr "Sobrescrever (s/N)? "
#: g10/openfile.c:85
msgid "writing to stdout\n"
msgstr "escrevendo para \"stdout\"\n"
#: g10/openfile.c:134
#, c-format
msgid "assuming signed data in '%s'\n"
msgstr "assumindo dados assinados em '%s'\n"
#: g10/openfile.c:181
#, c-format
msgid "%s: new options file created\n"
msgstr "%s: novo arquivo de opções criado\n"
#: g10/encr-data.c:59
#, c-format
msgid "%s encrypted data\n"
msgstr "dados codificados com\n"
#: g10/encr-data.c:61
#, c-format
msgid "encrypted with unknown algorithm %d\n"
msgstr "codificado com algoritmo desconhecido %d\n"
#: g10/encr-data.c:74
msgid ""
"WARNING: Message was encrypted with a weak key in the symmetric cipher.\n"
msgstr ""
"AVISO: A mensagem foi codificada com uma chave fraca na criptografia\n"
"simétrica.\n"
#: g10/seskey.c:52
msgid "weak key created - retrying\n"
msgstr "chave fraca criada - tentando novamente\n"
#: g10/seskey.c:57
#, c-format
msgid "cannot avoid weak key for symmetric cipher; tried %d times!\n"
msgstr ""
"impossível evitar chave fraca para criptografia simétrica;\n"
"tentado %d vezes!\n"
#. begin of list
#: g10/helptext.c:45
msgid "edit_ownertrust.value"
msgstr ""
#: g10/helptext.c:51
msgid "revoked_key.override"
msgstr ""
#: g10/helptext.c:55
msgid "untrusted_key.override"
msgstr ""
#: g10/helptext.c:59
msgid "pklist.user_id.enter"
msgstr ""
#: g10/helptext.c:63
msgid "keygen.algo"
msgstr ""
#: g10/helptext.c:79
msgid "keygen.algo.elg_se"
msgstr ""
#: g10/helptext.c:86
msgid "keygen.size"
msgstr ""
#: g10/helptext.c:90
msgid "keygen.size.huge.okay"
msgstr ""
#: g10/helptext.c:95
msgid "keygen.size.large.okay"
msgstr ""
#: g10/helptext.c:100
msgid "keygen.valid"
msgstr ""
#: g10/helptext.c:104
msgid "keygen.valid.okay"
msgstr ""
#: g10/helptext.c:109
msgid "keygen.name"
msgstr ""
#: g10/helptext.c:114
msgid "keygen.email"
msgstr ""
#: g10/helptext.c:118
msgid "keygen.comment"
msgstr ""
#: g10/helptext.c:123
msgid "keygen.userid.cmd"
msgstr ""
#: g10/helptext.c:132
msgid "keygen.sub.okay"
msgstr ""
#: g10/helptext.c:136
msgid "sign_uid.okay"
msgstr ""
#: g10/helptext.c:141
msgid "change_passwd.empty.okay"
msgstr ""
#: g10/helptext.c:146
msgid "keyedit.cmd"
msgstr ""
#: g10/helptext.c:150
msgid "keyedit.save.okay"
msgstr ""
#: g10/helptext.c:155
msgid "keyedit.cancel.okay"
msgstr ""
#: g10/helptext.c:159
msgid "keyedit.sign_all.okay"
msgstr ""
#: g10/helptext.c:163
msgid "keyedit.remove.uid.okay"
msgstr ""
#: g10/helptext.c:168
msgid "keyedit.remove.subkey.okay"
msgstr ""
#: g10/helptext.c:172
msgid "passphrase.enter"
msgstr ""
#: g10/helptext.c:179
msgid "passphrase.repeat"
msgstr ""
#: g10/helptext.c:183
msgid "detached_signature.filename"
msgstr ""
#: g10/helptext.c:187
msgid "openfile.overwrite.okay"
msgstr ""
#: g10/helptext.c:201
msgid "No help available"
msgstr "Nenhuma ajuda disponível"
#: g10/helptext.c:213
#, c-format
msgid "No help available for '%s'"
msgstr "Nenhuma ajuda disponível para '%s'"
diff --git a/po/ru.po b/po/ru.po
index ec2603dc9..cdd476ceb 100644
--- a/po/ru.po
+++ b/po/ru.po
@@ -1,3212 +1,3212 @@
# I finished the translation without looking at the contrib directory of
# GPG site. Werner enlightened me about two previous translations and I
# dared to look in them to correct my translation of questionable phrases.
# So I'd like to thank:
# Artem Belevich <artemb@usa.net>
# Alexey Morozov <morozov@iname.com>
# Michael Sobolev <mss@transas.com>, 1998
# Alexey Vyskubov <alexey@alv.stud.pu.ru>, 1998
# QingLong <qinglong@Bolizm> (couldn't send an email to let you know)
msgid ""
msgstr ""
"POT-Creation-Date: 1998-12-10 20:11+0100\n"
"Content-Type: text/plain; charset=\n"
"Date: 1998-01-26 22:08:36+0100\n"
"From: Gregory Steuck <steuck@iname.com>\n"
"Xgettext-Options: --default-domain=gnupg --directory=.. --add-comments "
"--keyword=_ --keyword=N_ --files-from=./POTFILES.in\n"
"Files: util/secmem.c util/argparse.c cipher/random.c cipher/rand-dummy.c "
"cipher/rand-unix.c cipher/rand-w32.c g10/g10.c g10/pkclist.c g10/keygen.c "
"g10/decrypt.c g10/encode.c g10/import.c g10/keyedit.c g10/keylist.c "
"g10/mainproc.c g10/passphrase.c g10/plaintext.c g10/pref.c g10/seckey-cert.c "
"g10/sig-check.c g10/sign.c g10/trustdb.c g10/verify.c\n"
#: util/secmem.c:77
msgid "Warning: using insecure memory!\n"
msgstr ""
"÷ÎÉÍÁÎÉÅ, ×ÏÚÍÏÖÎÁ ÕÔÅÞËÁ ÓÅËÒÅÔÎÙÈ ÄÁÎÎÙÈ!\n"
"üÔÕ ÐÒÏÂÌÅÍÕ ÍÏÖÎÏ ÒÅÛÉÔØ, ÕÓÔÁÎÏ×É× ÐÒÏÇÒÁÍÍÕ suid(root).\n"
"ïÂÒÁÔÉÔÅÓØ ÄÌÑ ÜÔÏÇÏ Ë ÁÄÍÉÎÉÓÔÒÁÔÏÒÕ ÷ÁÛÅÊ ÓÉÓÔÅÍÙ.\n"
#: util/miscutil.c:143
msgid "yes"
msgstr "ÄÁ(y)"
#: util/miscutil.c:144
msgid "yY"
msgstr "yY"
#: util/errors.c:54
msgid "General error"
msgstr "ïÂÝÁÑ ÏÛÉÂËÁ"
#: util/errors.c:55
msgid "Unknown packet type"
msgstr "îÅÉÚ×ÅÓÔÎÙÊ ÔÉÐ ÐÁËÅÔÁ"
#: util/errors.c:56
msgid "Unknown version"
msgstr "îÅÉÚ×ÅÓÔÎÁÑ ×ÅÒÓÉÑ"
#: util/errors.c:57
msgid "Unknown pubkey algorithm"
msgstr "îÅÉÚ×ÅÓÔÎÙÊ ÁÌÇÏÒÉÔÍ ÛÉÆÒÏ×ÁÎÉÑ Ó ÏÔËÒÙÔÙÍ ËÌÀÞÏÍ"
#: util/errors.c:58
msgid "Unknown digest algorithm"
msgstr "îÅÉÚ×ÅÓÔÎÙÊ ÁÌÇÏÒÉÔÍ ÇÅÎÅÒÁÃÉÉ ÄÁÊÄÖÅÓÔÁ"
#: util/errors.c:59
msgid "Bad public key"
msgstr "ðÌÏÈÏÊ ÏÔËÒÙÔÙÊ ËÌÀÞ"
#: util/errors.c:60
msgid "Bad secret key"
msgstr "ðÌÏÈÏÊ ÓÅËÒÅÔÎÙÊ ËÌÀÞ"
#: util/errors.c:61
msgid "Bad signature"
msgstr "ðÌÏÈÁÑ ÐÏÄÐÉÓØ"
#: util/errors.c:62
msgid "Checksum error"
msgstr "îÅÓÏ×ÐÁÄÅÎÉÅ ËÏÎÔÒÏÌØÎÏÊ ÓÕÍÍÙ"
#: util/errors.c:63
msgid "Bad passphrase"
msgstr "îÅ×ÅÒÎÁÑ \"ËÌÀÞÅ×ÁÑ ÆÒÁÚÁ\""
#: util/errors.c:64
msgid "Public key not found"
msgstr "ïÔËÒÙÔÙÊ ËÌÀÞ ÎÅ ÎÁÊÄÅÎ"
#: util/errors.c:65
msgid "Unknown cipher algorithm"
msgstr "îÅÉÚ×ÅÓÔÎÙÊ ÁÌÇÏÒÉÔÍ ÛÉÆÒÏ×ÁÎÉÑ"
#: util/errors.c:66
msgid "Can't open the keyring"
msgstr "îÅ×ÏÚÍÏÖÎÏ ÏÔËÒÙÔØ \"Ó×ÑÚËÕ ËÌÀÞÅÊ\""
#: util/errors.c:67
msgid "Invalid packet"
msgstr "îÅÄÏÐÕÓÔÉÍÙÊ ÐÁËÅÔ"
#: util/errors.c:68
msgid "Invalid armor"
msgstr "îÅÄÏÐÕÓÔÉÍÁÑ ASCII-ËÏÄÉÒÏ×ËÁ"
#: util/errors.c:69
msgid "No such user id"
msgstr "îÅÉÚ×ÅÓÔÎÙÊ ÉÄÅÎÔÉÆÉËÁÔÏÒ ÐÏÌØÚÏ×ÁÔÅÌÑ"
#: util/errors.c:70
msgid "Secret key not available"
msgstr "óÅËÒÅÔÎÙÊ ËÌÀÞ ÎÅ ÓÕÝÅÓÔ×ÕÅÔ"
#: util/errors.c:71
msgid "Wrong secret key used"
msgstr "éÓÐÏÌØÚÏ×ÁÎ ÎÅÐÒÁ×ÉÌØÎÙÊ ÓÅËÒÅÔÎÙÊ ËÌÀÞ"
#: util/errors.c:72
msgid "Not supported"
msgstr "îÅ ÐÏÄÄÅÒÖÉ×ÁÅÔÓÑ"
#: util/errors.c:73
msgid "Bad key"
msgstr "ðÌÏÈÏÊ ËÌÀÞ"
#: util/errors.c:74
msgid "File read error"
msgstr "ïÛÉÂËÁ ÞÔÅÎÉÑ ÆÁÊÌÁ"
#: util/errors.c:75
msgid "File write error"
msgstr "ïÛÉÂËÁ ÚÁÐÉÓÉ ÆÁÊÌÁ"
#: util/errors.c:76
msgid "Unknown compress algorithm"
msgstr "îÅÉÚ×ÅÓÔÎÙÊ ÁÌÇÏÒÉÔÍ ÕÐÁËÏ×ËÉ"
#: util/errors.c:77
msgid "File open error"
msgstr "ïÛÉÂËÁ ÏÔËÒÙÔÉÑ ÆÁÊÌÁ"
#: util/errors.c:78
msgid "File create error"
msgstr "ïÛÉÂËÁ ÓÏÚÄÁÎÉÑ ÆÁÊÌÁ"
#: util/errors.c:79
msgid "Invalid passphrase"
msgstr "îÅ×ÅÒÎÁÑ \"ËÌÀÞÅ×ÁÑ ÆÒÁÚÁ\""
#: util/errors.c:80
msgid "Unimplemented pubkey algorithm"
msgstr "îÅÒÅÁÌÉÚÏ×ÁÎÎÙÊ ÁÌÇÏÒÉÔÍ ÛÉÆÒÏ×ÁÎÉÑ Ó ÏÔËÒÙÔÙÍ ËÌÀÞÏÍ"
#: util/errors.c:81
msgid "Unimplemented cipher algorithm"
msgstr "îÅÒÅÁÌÉÚÏ×ÁÎÎÙÊ ÁÌÇÏÒÉÔÍ ÛÉÆÒÏ×ÁÎÉÑ"
#: util/errors.c:82
msgid "Unknown signature class"
msgstr "ðÏÄÐÉÓØ ÎÅÉÚ×ÅÓÔÎÏÇÏ ÔÉÐÁ"
#: util/errors.c:83
msgid "Trust database error"
msgstr "ïÛÉÂËÁ × Trust-DB (ÂÁÚÁ ÄÁÎÎÙÈ ÄÏ×ÅÒÉÑ)"
#: util/errors.c:84
msgid "Bad MPI"
msgstr ""
#: util/errors.c:85
msgid "Resource limit"
msgstr "îÅÄÏÓÔÁÔÏÞÎÏ ÒÅÓÕÒÓÏ×"
#: util/errors.c:86
msgid "Invalid keyring"
msgstr "îÅÄÏÐÕÓÔÉÍÁÑ \"Ó×ÑÚËÁ ËÌÀÞÅÊ\""
#: util/errors.c:87
msgid "Bad certificate"
msgstr "ðÌÏÈÏÊ ÓÅÒÔÉÆÉËÁÔ"
#: util/errors.c:88
msgid "Malformed user id"
msgstr "îÅÄÏÐÕÓÔÉÍÁÑ ÆÏÒÍÁ ÉÄÅÎÔÉÆÉËÁÔÏÒÁ ÐÏÌØÚÏ×ÁÔÅÌÑ"
#: util/errors.c:89
msgid "File close error"
msgstr "ïÛÉÂËÁ ÚÁËÒÙÔÉÑ ÆÁÊÌÁ"
#: util/errors.c:90
msgid "File rename error"
msgstr "ïÛÉÂËÁ ÐÅÒÅÉÍÅÎÏ×ÁÎÉÑ ÆÁÊÌÁ"
#: util/errors.c:91
msgid "File delete error"
msgstr "ïÛÉÂËÁ ÕÄÁÌÅÎÉÑ ÆÁÊÌÁ"
#: util/errors.c:92
msgid "Unexpected data"
msgstr "îÅÏÖÉÄÁÎÎÙÅ ÄÁÎÎÙÅ"
#: util/errors.c:93
msgid "Timestamp conflict"
msgstr "ëÏÎÆÌÉËÔ ×ÒÅÍÅÎÎÙÈ ÏÔÐÅÞÁÔËÏ× (timestamp)"
#: util/errors.c:94
msgid "Unusable pubkey algorithm"
msgstr "îÅÐÒÉÇÏÄÎÙÊ ÄÌÑ ÉÓÐÏÌØÚÏ×ÁÎÉÑ ÁÌÇÏÒÉÔÍ ÏÔËÒÙÔÏÇÏ ËÌÀÞÁ"
#: util/errors.c:95
msgid "File exists"
msgstr "æÁÊÌ ÓÕÝÅÓÔ×ÕÅÔ"
#: util/errors.c:96
msgid "Weak key"
msgstr "óÌÁÂÙÊ ËÌÀÞ"
#: util/logger.c:178
#, fuzzy, c-format
msgid "... this is a bug (%s:%d:%s)\n"
msgstr "ïÊ-ÊÏ ... ÏÛÉÂËÁ × ÐÒÏÇÒÁÍÍÅ (%s:%d:%s)\n"
#: util/logger.c:184
#, c-format
msgid "you found a bug ... (%s:%d)\n"
msgstr "÷Ù ÎÁÛÌÉ ÏÛÉÂËÕ × ÐÒÏÇÒÁÍÍÅ ... (%s:%d)\n"
#: cipher/random.c:412
#, fuzzy
msgid "WARNING: using insecure random number generator!!\n"
msgstr "÷ÎÉÍÁÎÉÅ: ÉÓÐÏÌØÚÕÅÔÓÑ ÎÅÎÁÄÅÖÎÙÊ ÇÅÎÅÒÁÔÏÒ ÓÌÕÞÁÊÎÙÈ ÞÉÓÅÌ!\n"
#: cipher/random.c:413
msgid ""
"The random number generator is only a kludge to let\n"
"it run - it is in no way a strong RNG!\n"
"\n"
"DON'T USE ANY DATA GENERATED BY THIS PROGRAM!!\n"
"\n"
msgstr ""
"éÓÐÏÌØÚÕÅÍÙÊ ÇÅÎÅÒÁÔÏÒ ÓÌÕÞÁÊÎÙÈ ÞÉÓÅÌ -- ÔÏÌØËÏ ÚÁÇÌÕÛËÁ,\n"
"ÞÔÏÂÙ ÓËÏÍÐÉÌÉÒÏ×ÁÔØ ÐÒÏÇÒÁÍÍÕ, ÎÉËÁË ÎÅ ÎÁÄÅÖÎÙÊ çóþ!\n"
"\n"
"îå ðïìøúõêôåóø äáîîùíé óïúäáîîùíé üôïê ðòïçòáííïê!\n"
"\n"
#: cipher/rndlinux.c:116
#, c-format
msgid ""
"\n"
"Not enough random bytes available. Please do some other work to give\n"
"the OS a chance to collect more entropy! (Need %d more bytes)\n"
msgstr ""
"\n"
"îÅÄÏÓÔÁÔÏÞÎÏ ÓÌÕÞÁÊÎÙÈ ÄÁÎÎÙÈ. ðÏÖÁÌÕÊÓÔÁ, ÐÏÄÅÌÁÊÔÅ ÞÔÏ-ÎÉÂÕÄØ, ÞÔÏÂÙ\n"
"ïó ÍÏÇÌÁ ÎÁÂÒÁÔØ ÄÏÐÏÌÎÉÔÅÌØÎÙÅ ÓÌÕÞÁÊÎÙÅ ÞÉÓÌÁ! (ÎÕÖÎÏ ÅÝÅ %d ÂÁÊÔ)\n"
#: g10/g10.c:159
msgid ""
"@Commands:\n"
" "
msgstr ""
"@ëÏÍÁÎÄÙ:\n"
" "
#: g10/g10.c:162
#, fuzzy
msgid "|[file]|make a signature"
msgstr "|[ÆÁÊÌ]|ÓÏÚÄÁÔØ ÐÏÄÐÉÓØ"
#: g10/g10.c:163
#, fuzzy
msgid "|[file]|make a clear text signature"
msgstr "|[ÆÁÊÌ]|ÓÏÚÄÁÔØ ÔÅËÓÔÏ×ÕÀ ÐÏÄÐÉÓØ"
#: g10/g10.c:164
msgid "make a detached signature"
msgstr "ÓÏÚÄÁÔØ ÏÔÄÅÌØÎÕÀ ÐÏÄÐÉÓØ"
#: g10/g10.c:165
msgid "encrypt data"
msgstr "ÚÁÛÉÆÒÏ×ÁÔØ ÄÁÎÎÙÅ"
#: g10/g10.c:166
msgid "encryption only with symmetric cipher"
msgstr "ÚÁÛÉÆÒÏ×ÁÔØ ÓÉÍÍÅÔÒÉÞÎÙÍ ÁÌÇÏÒÉÔÍÏÍ"
#: g10/g10.c:167
msgid "store only"
msgstr "ÔÏÌØËÏ ÓÏÈÒÁÎÉÔØ"
#: g10/g10.c:168
msgid "decrypt data (default)"
msgstr "ÒÁÓÛÉÆÒÏ×ÁÔØ ÄÁÎÎÙÅ (ÐÏ ÕÍÏÌÞÁÎÉÀ)"
#: g10/g10.c:169
msgid "verify a signature"
msgstr "ÐÒÏ×ÅÒÉÔØ ÐÏÄÐÉÓØ"
#: g10/g10.c:171
msgid "list keys"
msgstr "ÓÐÉÓÏË ËÌÀÞÅÊ"
#: g10/g10.c:172
msgid "list keys and signatures"
msgstr "ÓÐÉÓÏË ËÌÀÞÅÊ É ÐÏÄÐÉÓÅÊ"
#: g10/g10.c:173
msgid "check key signatures"
msgstr "ÐÒÏ×ÅÒÉÔØ ÐÏÄÐÉÓØ ÎÁ ËÌÀÞÅ"
#: g10/g10.c:174
msgid "list keys and fingerprints"
msgstr "ÓÐÉÓÏË ËÌÀÞÅÊ Ó ÉÈ \"ÏÔÐÅÞÁÔËÁÍÉ ÐÁÌØÃÅ×\""
#: g10/g10.c:175
msgid "list secret keys"
msgstr "ÓÐÉÓÏË ÓÅËÒÅÔÎÙÈ ËÌÀÞÅÊ"
#: g10/g10.c:177
msgid "generate a new key pair"
msgstr "ÓÇÅÎÅÒÉÒÏ×ÁÔØ ÎÏ×ÕÀ ÐÁÒÕ ËÌÀÞÅÊ (ÏÔËÒÙÔÙÊ É ÓÅËÒÅÔÎÙÊ)"
#: g10/g10.c:179
msgid "remove key from the public keyring"
msgstr "ÕÄÁÌÉÔØ ËÌÀÞ ÓÏ Ó×ÑÚËÉ"
#: g10/g10.c:181
msgid "sign or edit a key"
msgstr "ÐÏÄÐÉÓÁÔØ ÉÌÉ ÒÅÄÁËÔÉÒÏ×ÁÔØ ËÌÀÞ"
#: g10/g10.c:182
msgid "generate a revocation certificate"
msgstr "ÓÇÅÎÅÒÉÒÏ×ÁÔØ ÏÔÚÙ×ÁÀÝÉÊ ÓÅÒÔÉÆÉËÁÔ"
#: g10/g10.c:184
msgid "export keys"
msgstr "ÜËÓÐÏÒÔÉÒÏ×ÁÔØ ËÌÀÞÉ"
#: g10/g10.c:187
msgid "import/merge keys"
msgstr "ÉÍÐÏÒÔÉÒÏ×ÁÔØ/ÄÏÂÁ×ÉÔØ ËÌÀÞÉ"
#: g10/g10.c:189
msgid "list only the sequence of packets"
msgstr "ÎÁÐÅÞÁÔÁÔØ ÔÏÌØËÏ ÐÏÓÌÅÄÏ×ÁÔÅÌØÎÏÓÔØ ÐÁËÅÔÏ×"
#: g10/g10.c:192
#, fuzzy
msgid "export the ownertrust values"
msgstr "ÜËÓÐÏÒÔÉÒÏ×ÁÔØ ÐÁÒÁÍÅÔÒÙ ÄÏ×ÅÒÉÑ\n"
#: g10/g10.c:194
#, fuzzy
msgid "import ownertrust values"
msgstr "ÉÍÐÏÒÔÉÒÏ×ÁÔØ ÐÁÒÁÍÅÔÒÙ ÄÏ×ÅÒÉÑ\n"
#: g10/g10.c:196
#, fuzzy
msgid "|[NAMES]|update the trust database"
msgstr "|[éíåîá]|ÐÒÏ×ÅÒÉÔØ ÂÁÚÕ ÄÁÎÎÙÈ ÄÏ×ÅÒÉÑ"
#: g10/g10.c:198
msgid "|[NAMES]|check the trust database"
msgstr "|[éíåîá]|ÐÒÏ×ÅÒÉÔØ ÂÁÚÕ ÄÁÎÎÙÈ ÄÏ×ÅÒÉÑ"
#: g10/g10.c:199
msgid "fix a corrupted trust database"
msgstr "ÉÓÐÒÁ×ÉÔØ ÒÁÚÒÕÛÅÎÎÕÀ ÂÁÚÕ ÄÁÎÎÙÈ ÄÏ×ÅÒÉÑ"
#: g10/g10.c:200
msgid "De-Armor a file or stdin"
msgstr "äÅËÏÄÉÒÏ×ÁÔØ stdin ÉÌÉ ÆÁÊÌ ÉÚ ASCII-ÐÒÅÄÓÔÁ×ÌÅÎÉÑ"
#: g10/g10.c:201
msgid "En-Armor a file or stdin"
msgstr "úÁËÏÄÉÒÏ×ÁÔØ stdin ÉÌÉ ÆÁÊÌ × ASCII-ÐÒÅÄÓÔÁ×ÌÅÎÉÅ"
#: g10/g10.c:202
msgid "|algo [files]|print message digests"
msgstr "|algo [files]|ÎÁÐÅÞÁÔÁÔØ ÄÁÊÄÖÅÓÔ ÓÏÏÂÝÅÎÉÑ"
#: g10/g10.c:203
msgid "print all message digests"
msgstr "ÎÁÐÅÞÁÔÁÔØ ×ÓÅ ÄÁÊÄÖÅÓÔÙ ÓÏÏÂÝÅÎÉÑ"
#: g10/g10.c:210
msgid ""
"@\n"
"Options:\n"
" "
msgstr ""
"@\n"
"ðÁÒÁÍÅÔÒÙ:\n"
" "
#: g10/g10.c:212
msgid "create ascii armored output"
msgstr "×Ù×ÏÄ × ASCII-ÐÒÅÄÓÔÁ×ÌÅÎÉÉ"
#: g10/g10.c:214
msgid "use this user-id to sign or decrypt"
msgstr ""
"ÉÓÐÏÌØÚÏ×ÁÔØ ÕËÁÚÁÎÎÙÊ ÉÄÅÎÔÉÆÉËÁÔÏÒ ÐÏÌØÚÏ×ÁÔÅÌÑ ÄÌÑ ÐÏÄÐÉÓÉ ÉÌÉ ÒÁÓÛÉÆÒÏ×ËÉ"
#: g10/g10.c:215
msgid "use this user-id for encryption"
msgstr "ÉÓÐÏÌØÚÏ×ÁÔØ ÕËÁÚÁÎÎÙÊ ÉÄÅÎÔÉÆÉËÁÔÏÒ ÐÏÌØÚÏ×ÁÔÅÌÑ ÄÌÑ ÛÉÆÒÏ×ÁÎÉÑ"
#: g10/g10.c:216
msgid "|N|set compress level N (0 disables)"
msgstr "|N|ÕÓÔÁÎÏ×ÉÔØ ÕÒÏ×ÅÎØ ÓÖÁÔÉÑ (0 - ÎÅ ÓÖÉÍÁÔØ)"
#: g10/g10.c:218
msgid "use canonical text mode"
msgstr "ÉÓÐÏÌØÚÏ×ÁÔØ ËÁÎÏÎÉÞÅÓËÉÊ ÔÅËÓÔÏ×ÙÊ ÒÅÖÉÍ"
#: g10/g10.c:220
msgid "use as output file"
msgstr "ÉÓÐÏÌØÚÏ×ÁÔØ × ËÁÞÅÓÔ×Å ×ÙÈÏÄÎÏÇÏ ÆÁÊÌÁ"
#: g10/g10.c:221
msgid "verbose"
msgstr "ÍÎÏÇÏÓÌÏ×ÎÙÊ"
#: g10/g10.c:222
msgid "be somewhat more quiet"
msgstr ""
#: g10/g10.c:223
#, fuzzy
msgid "force v3 signatures"
msgstr "ÐÒÏ×ÅÒÉÔØ ÐÏÄÐÉÓØ ÎÁ ËÌÀÞÅ"
#. { oDryRun, "dry-run", 0, N_("do not make any changes") },
#: g10/g10.c:225
msgid "batch mode: never ask"
msgstr "ÐÁËÅÔÎÙÊ ÒÅÖÉÍ: ÎÉÞÅÇÏ ÎÅ ÓÐÒÁÛÉ×ÁÔØ"
#: g10/g10.c:226
msgid "assume yes on most questions"
msgstr "ÏÔ×ÅÞÁÔØ \"ÄÁ\" ÎÁ ÂÏÌØÛÉÎÓÔ×Ï ×ÏÐÒÏÓÏ×"
#: g10/g10.c:227
msgid "assume no on most questions"
msgstr "ÏÔ×ÅÞÁÔØ \"ÎÅÔ\" ÎÁ ÂÏÌØÛÉÎÓÔ×Ï ×ÏÐÒÏÓÏ×"
#: g10/g10.c:228
msgid "add this keyring to the list of keyrings"
msgstr "ÄÏÂÁ×ÉÔØ ÜÔÕ Ó×ÑÚËÕ Ë ÓÐÉÓËÕ Ó×ÑÚÏË ËÌÀÞÅÊ"
#: g10/g10.c:229
msgid "add this secret keyring to the list"
msgstr "ÄÏÂÁ×ÉÔØ ÜÔÕ ÓÅËÒÅÔÎÕÀ Ó×ÑÚËÕ Ë ÓÐÉÓËÕ Ó×ÑÚÏË ËÌÀÞÅÊ"
#: g10/g10.c:230
msgid "|NAME|use NAME as default secret key"
msgstr "|éíñ|ÉÓÐÏÌØÚÏ×ÁÔØ éíñ × ËÁÞÅÓÔ×Å ÓÅËÒÅÔÎÏÇÏ ËÌÀÞÁ ÐÏ ÕÍÏÌÞÁÎÉÀ"
#: g10/g10.c:231
#, fuzzy
msgid "|NAME|set terminal charset to NAME"
msgstr "|éíñ|ÉÓÐÏÌØÚÏ×ÁÔØ ÛÉÆÒÏ×ÁÌØÎÙÊ ÁÌÇÏÒÉÔÍÏÍ éíñ"
#: g10/g10.c:232
msgid "read options from file"
msgstr "ÞÉÔÁÔØ ÐÁÒÁÍÅÔÒÙ ÉÚ ÆÁÊÌÁ"
#: g10/g10.c:234
msgid "set debugging flags"
msgstr "ÕÓÔÁÎÏ×ÉÔØ ÏÔÌÁÄÏÞÎÙÅ ÆÌÁÇÉ"
#: g10/g10.c:235
msgid "enable full debugging"
msgstr "ÒÁÚÒÅÛÉÔØ ×ÓÀ ÏÔÌÁÄËÕ"
#: g10/g10.c:236
msgid "|FD|write status info to this FD"
msgstr "|FD| ÚÁÐÉÓÙ×ÁÔØ ÉÎÆÏÒÍÁÃÉÀ Ï ÓÏÓÔÏÑÎÉÉ × ÄÅÓËÒÉÐÔÏÒ (FD)"
#: g10/g10.c:237
msgid "do not write comment packets"
msgstr "ÎÅ ÐÉÓÁÔØ ÐÁËÅÔÙ Ó ËÏÍÍÅÎÔÁÒÉÑÍÉ"
#: g10/g10.c:238
msgid "(default is 1)"
msgstr "(ÐÏ ÕÍÏÌÞÁÎÉÀ 1)"
#: g10/g10.c:239
msgid "(default is 3)"
msgstr "(ÐÏ ÕÍÏÌÞÁÎÉÀ 3)"
#: g10/g10.c:241
msgid "|KEYID|ulimately trust this key"
msgstr ""
#: g10/g10.c:242
#, fuzzy
msgid "|FILE|load extension module FILE"
msgstr "|æáêì|ÚÁÇÒÕÚÉÔØ æáêì Ó ÒÁÓÛÉÒÑÀÝÉÍÉ ÍÏÄÕÌÑÍÉ"
#: g10/g10.c:243
msgid "emulate the mode described in RFC1991"
msgstr "ÜÍÕÌÉÒÏ×ÁÔØ ÒÅÖÉÍ ÏÐÉÓÁÎÎÙÊ × RFC1991"
#: g10/g10.c:244
#, fuzzy
msgid "|N|use passphrase mode N"
msgstr "|N|ÉÓÐÏÌØÚÏ×ÁÔØ ËÌÀÞÅ×ÕÀ ÆÒÁÚÕ ÒÅÖÉÍÁ N\n"
#: g10/g10.c:246
#, fuzzy
msgid "|NAME|use message digest algorithm NAME for passphrases"
msgstr "|éíñ|ÉÓÐÏÌØÚÏ×ÁÔØ ÈÜÛ-ÁÌÇÏÒÉÔÍ éíñ ÄÌÑ ËÌÀÞÅ×ÙÈ ÆÒÁÚ"
#: g10/g10.c:248
#, fuzzy
msgid "|NAME|use cipher algorithm NAME for passphrases"
msgstr "|éíñ|ÉÓÐÏÌØÚÏ×ÁÔØ ÛÉÆÒÏ×ÁÌØÎÙÊ ÁÌÇÏÒÉÔÍÏÍ éíñ ÄÌÑ ËÌÀÞÅ×ÙÈ ÆÒÁÚ"
#: g10/g10.c:250
msgid "|NAME|use cipher algorithm NAME"
msgstr "|éíñ|ÉÓÐÏÌØÚÏ×ÁÔØ ÛÉÆÒÏ×ÁÌØÎÙÊ ÁÌÇÏÒÉÔÍÏÍ éíñ"
#: g10/g10.c:251
msgid "|NAME|use message digest algorithm NAME"
msgstr "|éíñ|ÉÓÐÏÌØÚÏ×ÁÔØ ÈÜÛ-ÁÌÇÏÒÉÔÍ éíñ"
#: g10/g10.c:252
msgid "|N|use compress algorithm N"
msgstr "|N|ÉÓÐÏÌØÚÏ×ÁÔØ ÁÌÇÏÒÉÔÍ ÓÖÁÔÉÑ N"
#: g10/g10.c:253
msgid "throw keyid field of encrypted packets"
msgstr "×ÙÂÒÁÓÙ×ÁÔØ ÐÏÌÅ keyid Õ ÚÁÛÉÆÒÏ×ÁÎÎÙÈ ÐÁËÅÔÏ×"
#: g10/g10.c:261
#, fuzzy
msgid ""
"@\n"
"Examples:\n"
"\n"
" -se -r Bob [file] sign and encrypt for user Bob\n"
" --clearsign [file] make a clear text signature\n"
" --detach-sign [file] make a detached signature\n"
" --list-keys [names] show keys\n"
" --fingerprint [names] show fingerprints\n"
msgstr ""
"@\n"
"ðÒÉÍÅÒÙ:\n"
"\n"
" -se -r Bob [file] ÐÏÄÐÉÓÁÔØ É ÚÁÛÉÆÒÏ×ÁÔØ ÄÌÑ ÐÏÌØÚÏ×ÁÔÅÌÑ Bob\n"
" --clearsign [file] ÓÄÅÌÁÔØ ÔÅËÓÔÏ×ÕÀ ÐÏÄÐÉÓØ\n"
" --detach-sign [file] ÓÄÅÌÁÔØ ÏÔÄÅÌØÎÕÀ ÐÏÄÐÉÓØ\n"
" --list-keys [names] ÐÏËÁÚÁÔØ ÓÐÉÓÏË ËÌÀÞÅÊ\n"
" --fingerprint [names] ÐÏËÁÚÁÔØ \"ÏÔÐÅÞÁÔËÉ ÐÁÌØÃÅ×\" ËÌÀÞÅÊ\n"
#: g10/g10.c:339
msgid "Please report bugs to <gnupg-bugs@gnu.org>.\n"
msgstr ""
"ðÏÖÁÌÕÊÓÔÁ, ÏÔÐÒÁ×ÌÑÊÔÅ ÓÏÏÂÝÅÎÉÑ Ï ÏÛÉÂËÁÈ ÐÏ ÁÄÒÅÓÕ "
"<gnupg-bugs@gnu.org>.\n"
#: g10/g10.c:344
msgid "Usage: gpgm [options] [files] (-h for help)"
msgstr "éÓÐÏÌØÚÏ×ÁÎÉÅ: gpgm [ÐÁÒÁÍÅÔÒÙ] [ÆÁÊÌÙ] (-h ÄÌÑ ÐÏÍÏÝÉ)"
#: g10/g10.c:346
msgid "Usage: gpg [options] [files] (-h for help)"
msgstr "éÓÐÏÌØÚÏ×ÁÎÉÅ: gpg [ÐÁÒÁÍÅÔÒÙ] [ÆÁÊÌÙ] (-h ÄÌÑ ÐÏÍÏÝÉ)"
#: g10/g10.c:351
#, fuzzy
msgid ""
"Syntax: gpgm [options] [files]\n"
"GnuPG maintenance utility\n"
msgstr ""
"óÉÎÔÁËÓÉÓ: gpgm [ÐÁÒÁÍÅÔÒÙ] [ÆÁÊÌÙ]\n"
"ðÒÏÇÒÁÍÍÁ ÓÏÐÒÏ×ÏÖÄÅÎÉÑ GNUPG\n"
#: g10/g10.c:354
msgid ""
"Syntax: gpg [options] [files]\n"
"sign, check, encrypt or decrypt\n"
"default operation depends on the input data\n"
msgstr ""
"óÉÎÔÁËÓÉÓ: gpg [ÐÁÒÁÍÅÔÒÙ] [ÆÁÊÌÙ]\n"
"ÐÏÄÐÉÓÙ×ÁÅÔ, ÐÒÏ×ÅÒÑÅÔ ÐÏÄÐÉÓÉ, ÛÉÆÒÕÅÔ ÉÌÉ ÒÁÓÛÉÆÒÏ×Ù×ÁÅÔ\n"
"ÒÅÖÉÍ ÒÁÂÏÔÙ ÚÁ×ÉÓÉÔ ÏÔ ×ÈÏÄÎÙÈ ÄÁÎÎÙÈ\n"
#: g10/g10.c:360
msgid ""
"\n"
"Supported algorithms:\n"
msgstr ""
"\n"
"ðÏÄÄÅÒÖÉ×ÁÅÍÙÅ ÁÌÇÏÒÉÔÍÙ:\n"
#: g10/g10.c:435
msgid "usage: gpgm [options] "
msgstr "éÓÐÏÌØÚÏ×ÁÎÉÅ: gpgm [ÐÁÒÁÍÅÔÒÙ] "
#: g10/g10.c:437
msgid "usage: gpg [options] "
msgstr "éÓÐÏÌØÚÏ×ÁÎÉÅ: gpg [ÐÁÒÁÍÅÔÒÙ] "
#: g10/g10.c:478
msgid "conflicting commands\n"
msgstr "Widersprüchliche Kommandos\n"
#: g10/g10.c:616
#, fuzzy, c-format
msgid "NOTE: no default option file '%s'\n"
msgstr "ÚÁÍÅÞÁÎÉÅ: ÆÁÊÌ ÐÁÒÁÍÅÔÒÏ× ÐÏ ÕÍÏÌÞÁÎÉÀ '%s' ÏÔÓÕÔÓÔ×ÕÅÔ\n"
#: g10/g10.c:620
#, c-format
msgid "option file '%s': %s\n"
msgstr "ÆÁÊÌ ÐÁÒÁÍÅÔÒÏ× '%s': %s\n"
#: g10/g10.c:627
#, c-format
msgid "reading options from '%s'\n"
msgstr "ÞÉÔÁÀÔÓÑ ÐÁÒÁÍÅÔÒÙ ÉÚ '%s'\n"
#: g10/g10.c:776
#, fuzzy, c-format
msgid "%s is not a valid character set\n"
msgstr "îÅÄÏÐÕÓÔÉÍÙÊ ÓÉÍ×ÏÌ × ËÏÍÍÅÎÔÁÒÉÉ.\n"
#: g10/g10.c:810 g10/g10.c:822
msgid "selected cipher algorithm is invalid\n"
msgstr "×ÙÂÒÁÎ ÎÅÄÏÐÕÓÔÉÍÙÊ ÁÌÇÏÒÉÔÍ ÛÉÆÒÏ×ÁÎÉÑ\n"
#: g10/g10.c:816 g10/g10.c:828
msgid "selected digest algorithm is invalid\n"
msgstr "×ÙÂÒÁÎ ÎÅÄÏÐÕÓÔÉÍÙÊ ÄÁÊÄÖÅÓÔ-ÁÌÇÏÒÉÔÍ\n"
#: g10/g10.c:831
#, c-format
msgid "compress algorithm must be in range %d..%d\n"
msgstr "ÁÌÇÏÒÉÔÍ ÕÐÁËÏ×ËÉ ÍÏÖÅÔ ÉÍÅÔØ ÚÎÁÞÅÎÉÑ ÏÔ %d ÄÏ %d\n"
#: g10/g10.c:833
msgid "completes-needed must be greater than 0\n"
msgstr "completes-needed ÄÏÌÖÅÎ ÂÙÔØ ÂÏÌØÛÅ 0\n"
#: g10/g10.c:835
msgid "marginals-needed must be greater than 1\n"
msgstr "marginals-needed ÄÏÌÖÅÎ ÂÙÔØ ÂÏÌØÛÅ 1\n"
#: g10/g10.c:837
msgid "max-cert-depth must be in range 1 to 255\n"
msgstr ""
#: g10/g10.c:840
#, fuzzy
msgid "NOTE: simple S2K mode (0) is strongly discouraged\n"
msgstr "ÚÁÍÅÞÁÎÉÅ: ÐÒÏÓÔÏÊ S2K ÒÅÖÉÍ (0) ÏÞÅÎØ ÎÅ ÒÅËÏÍÅÎÄÕÅÔÓÑ\n"
#: g10/g10.c:844
msgid "invalid S2K mode; must be 0, 1 or 3\n"
msgstr "ÎÅÄÏÐÕÓÔÉÍÙÊ ÒÅÖÉÍ S2K: ÄÏÌÖÅÎ ÂÙÔØ 0, 1 ÉÌÉ 3\n"
#: g10/g10.c:927
#, c-format
msgid "failed to initialize the TrustDB: %s\n"
msgstr "ïÛÉÂËÁ ÉÎÉÃÉÁÌÉÚÁÃÉÉ ÂÁÚÙ ÄÁÎÎÙÈ ÄÏ×ÅÒÉÑ: %s\n"
#: g10/g10.c:933
msgid "--store [filename]"
msgstr "--store [ÉÍÑ ÆÁÊÌÁ]"
#: g10/g10.c:941
msgid "--symmetric [filename]"
msgstr "--symmetric [ÉÍÑ ÆÁÊÌÁ]"
#: g10/g10.c:949
msgid "--encrypt [filename]"
msgstr "--encrypt [ÉÍÑ ÆÁÊÌÁ]"
#: g10/g10.c:962
msgid "--sign [filename]"
msgstr "--sign [ÉÍÑ ÆÁÊÌÁ]"
#: g10/g10.c:975
msgid "--sign --encrypt [filename]"
msgstr "--sign --encrypt [ÉÍÑ ÆÁÊÌÁ]"
#: g10/g10.c:989
msgid "--clearsign [filename]"
msgstr "--clearsign [ÉÍÑ ÆÁÊÌÁ]"
#: g10/g10.c:1001
msgid "--decrypt [filename]"
msgstr "--decrypt [ÉÍÑ ÆÁÊÌÁ]"
#: g10/g10.c:1010
#, fuzzy
msgid "--edit-key username [commands]"
msgstr "--edit-key ÉÍÑ-ÐÏÌØÚÏ×ÁÔÅÌÑ"
#: g10/g10.c:1026
msgid "--delete-secret-key username"
msgstr "--delete-secret-key ÉÍÑ-ÐÏÌØÚÏ×ÁÔÅÌÑ"
#: g10/g10.c:1029
msgid "--delete-key username"
msgstr "--delete-key ÉÍÑ-ÐÏÌØÚÏ×ÁÔÅÌÑ"
#: g10/encode.c:216 g10/g10.c:1052 g10/sign.c:301
#, c-format
msgid "can't open %s: %s\n"
msgstr "ÎÅ×ÏÚÍÏÖÎÏ ÏÔËÒÙÔØ ÆÁÊÌ '%s': %s\n"
#: g10/g10.c:1063
msgid "-k[v][v][v][c] [userid] [keyring]"
msgstr "-k[v][v][v][c] [ÉÄÅÎÔÉÆÉËÁÔÏÒ ÐÏÌØÚÏ×ÁÔÅÌÑ] [Ó×ÑÚËÁ ËÌÀÞÅÊ]"
#: g10/g10.c:1120
#, c-format
msgid "dearmoring failed: %s\n"
msgstr "ÏÛÉÂËÁ ÄÅËÏÄÉÒÏ×ÁÎÉÑ: %s\n"
#: g10/g10.c:1128
#, c-format
msgid "enarmoring failed: %s\n"
msgstr "ÏÛÉÂËÁ ËÏÄÉÒÏ×ÁÎÉÑ: %s\n"
#: g10/g10.c:1194
#, c-format
msgid "invalid hash algorithm '%s'\n"
msgstr "ÎÅÄÏÐÕÓÔÉÍÙÊ ÈÜÛ-ÁÌÇÏÒÉÔÍ '%s'\n"
#: g10/g10.c:1273
msgid "[filename]"
msgstr "[ÉÍÑ ÆÁÊÌÁ]"
#: g10/g10.c:1277
msgid "Go ahead and type your message ...\n"
msgstr ""
#: g10/decrypt.c:59 g10/g10.c:1280 g10/verify.c:66
#, c-format
msgid "can't open '%s'\n"
msgstr "ÎÅ×ÏÚÍÏÖÎÏ ÏÔËÒÙÔØ ÆÁÊÌ '%s'\n"
#: g10/armor.c:344 g10/armor.c:391
msgid "armor header: "
msgstr ""
#: g10/armor.c:355
#, fuzzy
msgid "invalid clearsig header\n"
msgstr "ÎÅÄÏÐÕÓÔÉÍÏÅ ÎÁÞÁÌÏ ÔÅËÓÔÏ×ÏÊ ÐÏÄÐÉÓÉ\n"
#: g10/armor.c:382
msgid "invalid armor header: "
msgstr ""
#: g10/armor.c:460
#, fuzzy, c-format
msgid "armor: %s\n"
msgstr "ëÏÄÉÒÏ×ËÁ: %s\n"
#: g10/armor.c:533
msgid "invalid dash escaped line: "
msgstr "ÎÅÄÏÐÕÓÔÉÍÁÑ ÓÔÒÏËÁ ÎÁÞÉÎÁÀÝÁÑÓÑ Ó ÍÉÎÕÓÏ×: "
#: g10/armor.c:602
msgid "invalid clear text header: "
msgstr "ÎÅÄÏÐÕÓÔÉÍÙÊ ÔÅËÓÔÏ×ÙÊ ÚÁÇÏÌÏ×ÏË: "
#: g10/armor.c:845
#, fuzzy, c-format
msgid "invalid radix64 character %02x skipped\n"
msgstr "ÎÅÄÏÐÕÓÔÉÍÙÊ ÄÌÑ ËÏÄÉÒÏ×ËÉ radix64 ÓÉÍ×ÏÌ %02x ÐÒÏÐÕÝÅÎ\n"
#: g10/armor.c:878
msgid "premature eof (no CRC)\n"
msgstr "ÎÅÏÖÉÄÁÎÎÙÊ ËÏÎÅÃ ÆÁÊÌÁ (ÎÅÔ CRC)\n"
#: g10/armor.c:897
msgid "premature eof (in CRC)\n"
msgstr "ÎÅÏÖÉÄÁÎÎÙÊ ËÏÎÅÃ ÆÁÊÌÁ (× CRC)\n"
#: g10/armor.c:901
msgid "malformed CRC\n"
msgstr "ÎÅÐÒÁ×ÉÌØÎÁÑ ÆÏÒÍÁ CRC\n"
#: g10/armor.c:905
#, c-format
msgid "CRC error; %06lx - %06lx\n"
msgstr "ÏÛÉÂËÁ CRC; %06lx - %06lx\n"
#: g10/armor.c:924
msgid "premature eof (in Trailer)\n"
msgstr "ÎÅÏÖÉÄÁÎÎÙÊ ËÏÎÅà ÆÁÊÌÁ (× È×ÏÓÔÅ)\n"
#: g10/armor.c:928
msgid "error in trailer line\n"
msgstr "ÏÛÉÂËÁ × ÚÁ×ÅÒÛÁÀÝÅÊ ÓÔÒÏËÅ\n"
#: g10/armor.c:1182
msgid "no valid RFC1991 or OpenPGP data found.\n"
msgstr "ÎÅ ÎÁÊÄÅÎÏ ÄÏÐÕÓÔÉÍÙÈ RFC1991 ÉÌÉ OpenPGP ÄÁÎÎÙÈ.\n"
#: g10/pkclist.c:121
#, fuzzy, c-format
msgid ""
"No trust value assigned to %lu:\n"
"%4u%c/%08lX %s \""
msgstr ""
"îÅ ÏÐÒÅÄÅÌÅÎÙ ÐÁÒÁÍÅÔÒÙ ÄÏ×ÅÒÉÑ ÄÌÑ %lu:\n"
"%4u%c/%08lX %s \""
#: g10/pkclist.c:131
#, fuzzy
msgid ""
"Please decide how far you trust this user to correctly\n"
"verify other users' keys (by looking at passports,\n"
"checking fingerprints from different sources...)?\n"
"\n"
" 1 = Don't know\n"
" 2 = I do NOT trust\n"
" 3 = I trust marginally\n"
" 4 = I trust fully\n"
" s = please show me more information\n"
msgstr ""
"\"\n"
"\n"
"ðÏÖÁÌÕÊÓÔÁ ÒÅÛÉÔÅ, ÎÁÓËÏÌØËÏ ×Ù ÄÏ×ÅÒÑÅÔÅ ÜÔÏÍÕ ÐÏÌØÚÏ×ÁÔÅÌÀ ÐÒÏ×ÅÒÑÔØ\n"
"ÞÕÖÉÅ ËÌÀÞÉ (ÇÌÑÄÑ × ÐÁÓÐÏÒÔÁ, ÐÒÏ×ÅÒÑÑ \"ÏÔÐÅÞÁÔËÉ ÐÁÌØÃÅ×\" ÐÏ ÄÒÕÇÉÍ\n"
"ÉÓÔÏÞÎÉËÁÍ)?\n"
"\n"
" 1 = îÅ ÚÎÁÀ\n"
" 2 = îÅÔ, ÎÅ ÄÏ×ÅÒÑÀ\n"
" 3 = ÷ÅÒÀ ÏÔÞÁÓÔÉ\n"
" 4 = ÷ÅÒÀ ÐÏÌÎÏÓÔØÀ\n"
" s = ðÏÖÁÌÕÊÓÔÁ, ÐÏËÁÖÉÔÅ ÄÏÐÏÌÎÉÔÅÌØÎÕÀ ÉÎÆÏÒÍÁÃÉÀ\n"
#: g10/pkclist.c:140
msgid " m = back to the main menu\n"
msgstr " m = ÏÂÒÁÔÎÏ × ÇÌÁ×ÎÏÅ ÍÅÎÀ\n"
# valid user replies (not including 1..4)
#. a string with valid answers
#: g10/pkclist.c:145
msgid "sSmM"
msgstr "sSmM"
#: g10/pkclist.c:149
msgid "Your decision? "
msgstr "÷ÁÛÅ ÒÅÛÅÎÉÅ? "
#: g10/pkclist.c:169
msgid "Certificates leading to an ultimately trusted key:\n"
msgstr ""
#: g10/pkclist.c:197
msgid ""
"Could not find a valid trust path to the key. Let's see whether we\n"
"can assign some missing owner trust values.\n"
"\n"
msgstr ""
"îÅ ÐÏÌÕÞÉÌÏÓØ ÎÁÊÔÉ ÃÅÐÏÞËÕ ÄÏ×ÅÒÉÑ ÄÌÑ ËÌÀÞÁ. ðÏÓÍÏÔÒÉÍ, ÍÏÖÎÏ ÌÉ "
"ÐÒÉÓ×ÏÉÔØ\n"
"ÎÅËÏÔÏÒÙÅ ÎÅÄÏÓÔÁÀÝÉÅ ÚÎÁÞÅÎÉÑ \"ÄÏ×ÅÒÉÑ ×ÌÁÄÅÌØÃÕ\"\n"
"\n"
#: g10/pkclist.c:219
msgid ""
"No path leading to one of our keys found.\n"
"\n"
msgstr ""
#: g10/pkclist.c:221
msgid ""
"No certificates with undefined trust found.\n"
"\n"
msgstr ""
#: g10/pkclist.c:223
#, fuzzy
msgid ""
"No trust values changed.\n"
"\n"
msgstr "úÎÁÞÅÎÉÑ ÐÁÒÁÍÅÔÒÏ× ÄÏ×ÅÒÉÑ ÎÅ ÉÚÍÅÎÅÎÙ.\n"
#: g10/pkclist.c:238
#, fuzzy, c-format
msgid "key %08lX: key has been revoked!\n"
msgstr "build_sigrecs: ËÌÀÞ ist widerrufen\n"
#: g10/pkclist.c:244 g10/pkclist.c:335
msgid "Use this key anyway? "
msgstr "÷ÓÅ ÒÁ×ÎÏ ÉÓÐÏÌØÚÏ×ÁÔØ ÜÔÏÔ ËÌÀÞ?"
#: g10/pkclist.c:266
#, fuzzy, c-format
msgid "%08lX: key has expired\n"
msgstr "úÁÍÅÞÁÎÉÅ: óÒÏË ÄÅÊÓÔ×ÉÑ ËÌÀÞÁ ÕÖÅ ÉÓÔÅË!\n"
#: g10/pkclist.c:272
#, c-format
msgid "%08lX: no info to calculate a trust probability\n"
msgstr ""
#: g10/pkclist.c:288
#, fuzzy, c-format
msgid "%08lX: We do NOT trust this key\n"
msgstr "÷îéíáîéå: íÙ îå ÄÏ×ÅÒÑÅÍ ÜÔÏÍÕ ËÌÀÞÕ!\n"
#: g10/pkclist.c:294
#, c-format
msgid ""
"%08lX: It is not sure that this key really belongs to the owner\n"
"but it is accepted anyway\n"
msgstr ""
#: g10/pkclist.c:300
msgid "This key probably belongs to the owner\n"
msgstr ""
#: g10/pkclist.c:305
msgid "This key belongs to us\n"
msgstr ""
#: g10/pkclist.c:330
msgid ""
"It is NOT certain that the key belongs to its owner.\n"
"If you *really* know what you are doing, you may answer\n"
"the next question with yes\n"
"\n"
msgstr ""
"îÅ×ÏÚÍÏÖÎÏ ÕÓÔÁÎÏ×ÉÔØ ÄÏÓÔÏ×ÅÒÎÏ, ÞÔÏ ËÌÀÞ ÐÒÉÎÁÄÌÅÖÉÔ ÔÏÍÕ,\n"
"ËÔÏ ÕËÁÚÁÎ ÅÇÏ ×ÌÁÄÅÌØÃÅÍ. ïÔ×ÅÞÁÊÔÅ \"ÄÁ\" ÎÁ ÓÌÅÄÕÀÝÉÊ ×ÏÐÒÏÓ,\n"
"ÔÏÌØËÏ ÅÓÌÉ ×Ù *ÄÅÊÓÔ×ÉÔÅÌØÎÏ* ÐÏÎÉÍÁÅÔÅ ÞÔÏ ÄÅÌÁÅÔÅ.\n"
#: g10/pkclist.c:339
msgid "WARNING: Using untrusted key!\n"
msgstr "÷îéíáîéå: éÓÐÏÌØÚÕÅÔÓÑ ËÌÀÞ Ë ËÏÔÏÒÏÍÕ ÎÅÔ ÄÏ×ÅÒÉÑ!\n"
#: g10/pkclist.c:375
msgid "WARNING: This key has been revoked by its owner!\n"
msgstr "÷îéíáîéå: ÷ÌÁÄÅÌÅà ËÌÀÞÁ ÕÖÅ ÏÔÏÚ×ÁÌ ÅÇÏ!\n"
#: g10/pkclist.c:376
msgid " This could mean that the signature is forgery.\n"
msgstr " üÔÏ ÍÏÖÅÔ ÏÚÎÁÞÁÔØ, ÞÔÏ ÐÏÄÐÉÓØ ÐÏÄÄÅÌØÎÁÑ.\n"
#: g10/pkclist.c:397
msgid "Note: This key has expired!\n"
msgstr "úÁÍÅÞÁÎÉÅ: óÒÏË ÄÅÊÓÔ×ÉÑ ËÌÀÞÁ ÕÖÅ ÉÓÔÅË!\n"
#: g10/pkclist.c:404
msgid "WARNING: This key is not certified with a trusted signature!\n"
msgstr "÷îéíáîéå: üÔÏÔ ËÌÀÞ ÎÅ ÚÁ×ÅÒÅÎ ÄÏ×ÅÒÅÎÎÏÊ ÐÏÄÐÉÓØÀ!\n"
#: g10/pkclist.c:406
msgid ""
" There is no indication that the signature belongs to the owner.\n"
msgstr ""
" îÅÔ ÎÉËÁËÉÈ ÕËÁÚÁÎÉÑ ÎÁ ÔÏ, ÞÔÏ ËÌÀÞ ÐÒÉÎÁÄÌÅÖÉÔ ÅÇÏ ×ÌÁÄÅÌØÃÕ.\n"
#: g10/pkclist.c:421
msgid "WARNING: We do NOT trust this key!\n"
msgstr "÷îéíáîéå: íÙ îå ÄÏ×ÅÒÑÅÍ ÜÔÏÍÕ ËÌÀÞÕ!\n"
#: g10/pkclist.c:422
msgid " The signature is probably a FORGERY.\n"
msgstr " ðÏÄÐÉÓØ ×ÅÒÏÑÔÎÏ -- ðïääåìëá.\n"
#: g10/pkclist.c:429
msgid ""
"WARNING: This key is not certified with sufficiently trusted signatures!\n"
msgstr "÷îéíáîéå: üÔÏÔ ËÌÀÞ ÎÅ ÚÁ×ÅÒÅÎ ÄÏÓÔÁÔÏÞÎÏ ÄÏ×ÅÒÅÎÎÙÍÉ ÐÏÄÐÉÓÑÍÉ!\n"
#: g10/pkclist.c:432
msgid " It is not certain that the signature belongs to the owner.\n"
msgstr " îÅÔ Õ×ÅÒÅÎÎÏÓÔÉ, ÞÔÏ ÐÏÄÐÉÓØ ÐÒÉÎÁÄÌÅÖÉÔ ×ÌÁÄÅÌØÃÕ.\n"
#: g10/pkclist.c:477
msgid ""
"You did not specify a user ID. (you may use \"-r\")\n"
"\n"
msgstr ""
"÷Ù ÎÅ ÕËÁÚÁÌÉ ÉÄÅÎÔÉÆÉËÁÔÏÒ ÐÏÌØÚÏ×ÁÔÅÌÑ (×ÏÓÐÏÌØÚÕÊÔÅÓØ ÐÁÒÁÍÅÔÒÏÍ "
"\"-r\").\n"
"\n"
#: g10/pkclist.c:482
msgid "Enter the user ID: "
msgstr "÷×ÅÄÉÔÅ ÉÄÅÎÔÉÆÉËÁÔÏÒ ÐÏÌØÚÏ×ÁÔÅÌÑ: "
#: g10/pkclist.c:493
msgid "No such user ID.\n"
msgstr "îÅÔ ÔÁËÏÇÏ ÉÄÅÎÔÉÆÉËÁÔÏÒÁ ÐÏÌØÚÏ×ÁÔÅÌÑ.\n"
#: g10/pkclist.c:527 g10/pkclist.c:554
#, c-format
msgid "%s: skipped: %s\n"
msgstr "%s: ÐÒÏÐÕÝÅÎ: %s\n"
#: g10/pkclist.c:535
#, c-format
msgid "%s: error checking key: %s\n"
msgstr "%s: ÏÛÉÂËÁ ÐÒÉ ÐÒÏ×ÅÒËÅ ËÌÀÞÁ: %s\n"
#: g10/pkclist.c:561
msgid "no valid addressees\n"
msgstr "ÎÅÔ ÄÏÐÕÓÔÉÍÙÈ ÁÄÒÅÓÏ×\n"
#: g10/keygen.c:124
msgid "writing self signature\n"
msgstr "ÐÉÛÅÔÓÑ ÓÁÍÏ-ÐÏÄÐÉÓØ\n"
#: g10/keygen.c:162
msgid "writing key binding signature\n"
msgstr "ÐÉÛÅÔÓÑ \"key-binding\" ÐÏÄÐÉÓØ\n"
#: g10/keygen.c:388
msgid "Please select what kind of key you want:\n"
msgstr "÷ÙÂÅÒÉÔÅ ÖÅÌÁÅÍÙÊ ÔÉÐ ËÌÀÞÁ:\n"
#: g10/keygen.c:390
#, c-format
msgid " (%d) DSA and ElGamal (default)\n"
msgstr " (%d) DSA É ElGamal (ÐÏ ÕÍÏÌÞÁÎÉÀ)\n"
#: g10/keygen.c:391
#, c-format
msgid " (%d) DSA (sign only)\n"
msgstr " (%d) DSA (ÔÏÌØËÏ ÐÏÄÐÉÓØ)\n"
#: g10/keygen.c:393
#, c-format
msgid " (%d) ElGamal (encrypt only)\n"
msgstr " (%d) ElGamal (ÔÏÌØËÏ ÛÉÆÒÏ×ÁÎÉÅ)\n"
#: g10/keygen.c:394
#, c-format
msgid " (%d) ElGamal (sign and encrypt)\n"
msgstr " (%d) ElGamal (ÐÏÄÐÉÓØ É ÛÉÆÒÏ×ÁÎÉÅ)\n"
#: g10/keygen.c:396
#, c-format
msgid " (%d) ElGamal in a v3 packet\n"
msgstr " (%d) ElGamal × v3-ÐÁËÅÔÅ\n"
#: g10/keygen.c:401
msgid "Your selection? "
msgstr "÷ÁÛ ×ÙÂÏÒ? "
#: g10/keygen.c:411
#, fuzzy
msgid "Do you really want to create a sign and encrypt key? "
msgstr "÷Ù ÄÅÊÓÔ×ÉÔÅÌØÎÏ ÈÏÔÉÔÅ ÕÄÁÌÉÔØ ×ÙÂÒÁÎÎÙÅ ËÌÀÞÉ? "
#: g10/keygen.c:432
msgid "Invalid selection.\n"
msgstr "îÅÄÏÐÕÓÔÉÍÙÊ ×ÙÂÏÒ.\n"
#: g10/keygen.c:444
#, c-format
msgid ""
"About to generate a new %s keypair.\n"
" minimum keysize is 768 bits\n"
" default keysize is 1024 bits\n"
" highest suggested keysize is 2048 bits\n"
msgstr ""
"óÏÂÉÒÁÅÍÓÑ ÓÇÅÎÅÒÉÒÏ×ÁÔØ %s ËÌÀÞÅ×ÕÀ ÐÁÒÕ.\n"
" ÍÉÎÉÍÁÌØÎÁÑ ÄÌÉÎÁ ËÌÀÞÁ: 768 ÂÉÔ\n"
" ÄÌÉÎÁ ËÌÀÞÁ ÐÏ ÕÍÏÌÞÁÎÉÀ: 1024 ÂÉÔÁ\n"
" ÍÁËÓÉÍÁÌØÎÁÑ ÒÅËÏÍÅÎÄÕÅÍÁÑ ÄÌÉÎÁ ËÌÀÞÁ: 2048 ÂÉÔ\n"
#: g10/keygen.c:451
msgid "What keysize do you want? (1024) "
msgstr "ëÁËÏÇÏ ÒÁÚÍÅÒÁ ËÌÀÞ ×Ù ÖÅÌÁÅÔÅ? (1024)"
#: g10/keygen.c:456
msgid "DSA only allows keysizes from 512 to 1024\n"
msgstr "äÏÐÕÓÔÉÍÙÊ ÒÁÚÍÅÒ DSA ËÌÀÞÅÊ - ÏÔ 512 ÄÏ 1024 ÂÉÔ\n"
#: g10/keygen.c:458
msgid "keysize too small; 768 is smallest value allowed.\n"
msgstr "ÓÌÉÛËÏÍ ÍÁÌÅÎØËÁÑ ÄÌÉÎÁ ËÌÀÞÁ, ÎÁÉÍÅÎØÛÅÅ ÚÎÁÞÅÎÉÅ - 768.\n"
#: g10/keygen.c:461
#, fuzzy
msgid ""
"Keysizes larger than 2048 are not suggested because\n"
"computations take REALLY long!\n"
msgstr ""
"ëÌÀÞÉ ÄÌÉÎÏÊ ÂÏÌØÛÅ 2048 ÎÅ ÒÅËÏÍÅÎÄÕÀÔÓÑ, ÐÏÔÏÍÕ ÞÔÏ ×ÙÞÉÓÌÅÎÉÑÚÁÎÉÍÁÀÔ "
"ïþåîø ÍÎÏÇÏ ×ÒÅÍÅÎÉ!\n"
#: g10/keygen.c:464
msgid "Are you sure that you want this keysize? "
msgstr "÷Ù ÄÅÊÓÔ×ÉÔÅÌØÎÏ ÈÏÔÉÔÅ ËÌÀÞ ÔÁËÏÊ ÄÌÉÎÙ? "
#: g10/keygen.c:465
msgid ""
"Okay, but keep in mind that your monitor and keyboard radiation is also very "
"vulnerable to attacks!\n"
msgstr ""
"ïË, ÔÏÌØËÏ ÎÅ ÚÁÂÙ×ÁÊÔÅ, ÞÔÏ ÉÚÌÕÞÅÎÉÅ ×ÁÛÉÈ ËÌÁ×ÉÁÔÕÒÙ É ÍÏÎÉÔÏÒÁ ÔÏÖÅ\n"
"ÄÅÌÁÀÔ ×ÁÓ ÕÑÚ×ÉÍÙÍ ÄÌÑ ÁÔÁË.\n"
#: g10/keygen.c:473
msgid "Do you really need such a large keysize? "
msgstr "÷ÁÍ ÄÅÊÓÔ×ÉÔÅÌØÎÏ ÎÕÖÅÎ ÔÁËÏÊ ÄÌÉÎÎÙÊ ËÌÀÞ? "
#: g10/keygen.c:479
#, c-format
msgid "Requested keysize is %u bits\n"
msgstr "úÁÐÒÏÛÅÎÎÙÊ ËÌÀÞ ÉÍÅÅÔ ÄÌÉÎÕ %u ÂÉÔ\n"
#: g10/keygen.c:482 g10/keygen.c:486
#, c-format
msgid "rounded up to %u bits\n"
msgstr "ÏËÒÕÇÌÅÎÏ ÄÏ %u ÂÉÔ\n"
#: g10/keygen.c:499
msgid ""
"Please specify how long the key should be valid.\n"
" 0 = key does not expire\n"
" <n> = key expires in n days\n"
" <n>w = key expires in n weeks\n"
" <n>m = key expires in n months\n"
" <n>y = key expires in n years\n"
msgstr ""
"ðÏÖÁÌÕÊÓÔÁ, ÕËÁÖÉÔÅ ÐÒÏÄÏÌÖÉÔÅÌØÎÏÓÔØ ÄÅÊÓÔ×ÉÑ ×ÁÛÅÇÏ ËÌÀÞÁ.\n"
" 0 = ÂÅÓÓÒÏÞÎÙÊ ËÌÀÞ\n"
" <n> = ÓÒÏË ÄÅÊÓÔ×ÉÑ ËÌÀÞÁ n ÄÎÅÊ\n"
" <n>w = ÓÒÏË ÄÅÊÓÔ×ÉÑ ËÌÀÞÁ n ÎÅÄÅÌØ\n"
" <n>m = ÓÒÏË ÄÅÊÓÔ×ÉÑ ËÌÀÞÁ n ÍÅÓÑÃÅ×\n"
" <n>y = ÓÒÏË ÄÅÊÓÔ×ÉÑ ËÌÀÞÁ n ÌÅÔ\n"
#: g10/keygen.c:514
msgid "Key is valid for? (0) "
msgstr "ëÌÀÞ ÄÅÊÓÔ×ÉÔÅÌÅÎ × ÔÅÞÅÎÉÅ? (0) "
#: g10/keygen.c:525
msgid "invalid value\n"
msgstr "ÎÅÄÏÐÕÓÔÉÍÏÅ ÚÎÁÞÅÎÉÅ.\n"
#: g10/keygen.c:530
msgid "Key does not expire at all\n"
msgstr "âÅÓÓÒÏÞÎÙÊ ËÌÀÞ.\n"
#. print the date when the key expires
#: g10/keygen.c:536
#, c-format
msgid "Key expires at %s\n"
msgstr "ëÌÀÞ ÄÅÊÓÔ×ÕÅÔ ÄÏ %s\n"
#: g10/keygen.c:542
msgid "Is this correct (y/n)? "
msgstr "üÔÏ ×ÅÒÎÏ? (y/n) "
#: g10/keygen.c:584
msgid ""
"\n"
"You need a User-ID to identify your key; the software constructs the user "
"id\n"
"from Real Name, Comment and Email Address in this form:\n"
" \"Heinrich Heine (Der Dichter) <heinrichh@duesseldorf.de>\"\n"
"\n"
msgstr ""
"\n"
"äÌÑ ÉÄÅÎÔÉÆÉËÁÃÉÉ ËÌÀÞÁ ÎÅÏÂÈÏÄÉÍ ÉÄÅÎÔÉÆÉËÁÔÏÒ ÐÏÌØÚÏ×ÁÔÅÌÑ; ÐÒÏÇÒÁÍÍÁ\n"
"ËÏÎÓÔÒÕÉÒÕÅÔ ÅÇÏ ÉÚ ÐÏÌÎÏÇÏ ÉÍÅÎÉ ÐÏÌØÚÏ×ÁÔÅÌÑ, ËÏÍÍÅÎÔÁÒÉÑ É ÁÄÒÅÓÁ email× "
"×ÉÄÅ:\n"
" \"Vasya Pupkin (KRUTOI) <vasya@mega-cool.ru>\"\n"
"\n"
#: g10/keygen.c:595
msgid "Real name: "
msgstr "÷ÁÛÅ ÉÍÑ (\"éÍÑ æÁÍÉÌÉÑ\"): "
#: g10/keygen.c:599
msgid "Invalid character in name\n"
msgstr "îÅÄÏÐÕÓÔÉÍÙÊ ÓÉÍ×ÏÌ × ÉÍÅÎÉ\n"
#: g10/keygen.c:601
msgid "Name may not start with a digit\n"
msgstr "ðÏÌÎÏÅ ÉÍÑ ÎÅ ÍÏÖÅÔ ÎÁÞÉÎÁÔØÓÑ Ó ÃÉÆÒÙ.\n"
#: g10/keygen.c:603
msgid "Name must be at least 5 characters long\n"
msgstr "ðÏÌÎÏÅ ÉÍÑ ÄÏÌÖÎÏ ÓÏÓÔÏÑÔØ ÎÅ ÍÅÎÅÅ ÞÅÍ ÉÚ 5ÔÉ ÓÉÍ×ÏÌÏ×.\n"
#: g10/keygen.c:611
msgid "Email address: "
msgstr "E-Mail: "
#: g10/keygen.c:623
msgid "Not a valid email address\n"
msgstr "îÅÄÏÐÕÓÔÉÍÙÊ E-Mail\n"
#: g10/keygen.c:631
msgid "Comment: "
msgstr "ëÏÍÍÅÎÔÁÒÉÊ: "
#: g10/keygen.c:637
msgid "Invalid character in comment\n"
msgstr "îÅÄÏÐÕÓÔÉÍÙÊ ÓÉÍ×ÏÌ × ËÏÍÍÅÎÔÁÒÉÉ.\n"
#: g10/keygen.c:657
#, c-format
msgid ""
"You selected this USER-ID:\n"
" \"%s\"\n"
"\n"
msgstr ""
"÷Ù ×ÙÂÒÁÌÉ ÉÄÅÎÔÉÆÉËÁÔÏÒ ÐÏÌØÚÏ×ÁÔÅÌÑ:\n"
" \"%s\"\n"
"\n"
#: g10/keygen.c:660
msgid "NnCcEeOoQq"
msgstr ""
#: g10/keygen.c:670
#, fuzzy
msgid "Change (N)ame, (C)omment, (E)mail or (O)kay/(Q)uit? "
msgstr "éÚÍÅÎÉÔØ: N=éÍÑ, C=ëÏÍÍÅÎÔÁÒÉÊ, E=E-Mail, O=Okay/Q=÷ÙÈÏÄ? "
#: g10/keygen.c:722
msgid ""
"You need a Passphrase to protect your secret key.\n"
"\n"
msgstr ""
"äÌÑ ÚÁÝÉÔÙ ×ÁÛÅÇÏ ËÌÀÞÁ ÎÕÖÎÁ ËÌÀÞÅ×ÁÑ ÆÒÁÚÁ.\n"
"\n"
#: g10/keyedit.c:389 g10/keygen.c:730
msgid "passphrase not correctly repeated; try again.\n"
msgstr "ËÌÀÞÅ×ÁÑ ÆÒÁÚÁ ÎÅ ÂÙÌÁ ×ÏÓÐÒÏÉÚ×ÅÄÅÎÁ, ÐÏÐÒÏÂÕÊÔÅ ÓÎÏ×Á.\n"
#: g10/keygen.c:736
msgid ""
"You don't want a passphrase - this is probably a *bad* idea!\n"
"I will do it anyway. You can change your passphrase at any time,\n"
"using this program with the option \"--edit-key\".\n"
"\n"
msgstr ""
"÷Ù ÎÅ ÈÏÔÉÔÅ ÉÓÐÏÌØÚÏ×ÁÔØ ËÌÀÞÅ×ÕÀ ÆÒÁÚÕ - ÜÔÏ, ÓËÏÒÅÅ ×ÓÅÇÏ, *ÐÌÏÈÁÑ*\n"
"ÉÄÅÑ. îÏ Ñ ÓÄÅÌÁÀ, ÞÔÏ ÷Ù ÈÏÔÉÔÅ. ëÌÀÞÅ×ÕÀ ÆÒÁÚÕ ÍÏÖÎÏ ÓÍÅÎÉÔØ × ÌÀÂÏÅ\n"
"×ÒÅÍÑ, ÚÁÐÕÓÔÉ× ÜÔÕ ÐÒÏÇÒÁÍÍÕ Ó ÐÁÒÁÍÅÔÒÏÍ \"--edit-key\".\n"
"\n"
#: g10/keygen.c:757
msgid ""
"We need to generate a lot of random bytes. It is a good idea to perform\n"
"some other action (work in another window, move the mouse, utilize the\n"
"network and the disks) during the prime generation; this gives the random\n"
"number generator a better chance to gain enough entropy.\n"
msgstr ""
"îÁÍ ÎÕÖÎÏ ÓÇÅÎÅÒÉÒÏ×ÁÔØ ÍÎÏÇÏ ÓÌÕÞÁÊÎÙÈ ÂÁÊÔÏ×. óÅÊÞÁÓ ÏÞÅÎØ ÈÏÒÏÛÏ ÂÙÌÏ ÂÙ\n"
"ÞÔÏ-ÔÏ ÐÏÄÅÌÁÔØ ÎÁ ÍÁÛÉÎÅ (ÐÏÒÁÂÏÔÁÔØ × ÄÒÕÇÏÍ ÏËÎÅ, ÐÏÄ×ÉÇÁÔØ ÍÙÛØ,\n"
"ÎÁÇÒÕÚÉÔØ ÓÅÔÅ×ÕÀ ÉÌÉ ÄÉÓËÏ×ÕÀ ÐÏÄÓÉÓÔÅÍÕ). üÔÏ ÄÁÓÔ ÇÅÎÅÒÁÔÏÒÕ ÓÌÕÞÁÊÎÙÈ\n"
"ÞÉÓÅÌ ×ÏÚÍÏÖÎÏÓÔØ ÎÁÂÒÁÔØ ÄÏÓÔÁÔÏÞÎÏ ÜÎÔÒÏÐÉÉ.\n"
#: g10/keygen.c:827
msgid "Key generation can only be used in interactive mode\n"
msgstr "çÅÎÅÒÁÃÉÑ ËÌÀÞÁ ÍÏÖÅÔ ÂÙÔØ ×ÙÐÏÌÎÅÎÁ ÔÏÌØËÏ × ÉÎÔÅÒÁËÔÉ×ÎÏÍ ÒÅÖÉÍÅ.\n"
#: g10/keygen.c:835
msgid "DSA keypair will have 1024 bits.\n"
msgstr "ëÌÀÞÅ×ÁÑ ÐÁÒÁ DSA ÂÕÄÅÔ ÉÍÅÔØ ÄÌÉÎÕ 1024 ÂÉÔÁ.\n"
#: g10/keygen.c:841
#, fuzzy
msgid "Key generation cancelled.\n"
msgstr "çÅÎÅÒÁÃÉÑ ËÌÀÞÁ ÏÔÍÅÎÅÎÁ: %s\n"
#: g10/keygen.c:851
#, c-format
msgid "writing public certificate to '%s'\n"
msgstr "ÏÔËÒÙÔÙÊ ÓÅÒÔÉÆÉËÁÔ ÚÁÐÉÓÙ×ÁÅÔÓÑ × '%s'\n"
#: g10/keygen.c:852
#, c-format
msgid "writing secret certificate to '%s'\n"
msgstr "ÓÅËÒÅÔÎÙÊ ÓÅÒÔÉÆÉËÁÔ ÚÁÐÉÓÙ×ÁÅÔÓÑ × '%s'\n"
#: g10/keygen.c:929
msgid "public and secret key created and signed.\n"
msgstr "ÏÔËÒÙÔÙÊ É ÓÅËÒÅÔÎÙÊ ËÌÀÞÉ ÓÏÚÄÁÎÙ É ÐÏÄÐÉÓÁÎÙ.\n"
#: g10/keygen.c:931
msgid ""
"Note that this key cannot be used for encryption. You may want to use\n"
"the command \"--add-key\" to generate a secondary key for this purpose.\n"
msgstr ""
"ïÂÒÁÔÉÔÅ ×ÎÉÍÁÎÉÅ, ÞÔÏ ÜÔÏÔ ËÌÀÞ ÎÅ ÍÏÖÅÔ ÂÙÔØ ÉÓÐÏÌØÚÏ×ÁÎ ÄÌÑ ÛÉÆÒÏ×ÁÎÉÑ.\n"
"÷Ù ÍÏÖÅÔÅ ×ÏÓÐÏÌØÚÏ×ÁÔØÓÑ ÐÁÒÁÍÅÔÒÏÍ --add-key ÄÌÑ ÇÅÎÅÒÁÃÉÉ "
"ÄÏÐÏÌÎÉÔÅÌØÎÏÇÏ\n"
"ËÌÀÞÁ ÄÌÑ ÛÉÆÒÏ×ÁÎÉÑ.\n"
#: g10/keygen.c:945 g10/keygen.c:1030
#, c-format
msgid "Key generation failed: %s\n"
msgstr "çÅÎÅÒÁÃÉÑ ËÌÀÞÁ ÎÅ ÕÄÁÌÁÓØ: %s\n"
#: g10/keygen.c:1008
#, fuzzy
msgid "Really create? "
msgstr "äÅÊÓÔ×ÉÔÅÌØÎÏ ÓÏÚÄÁÔØ? "
#: g10/encode.c:88 g10/openfile.c:81 g10/openfile.c:158 g10/tdbio.c:445
#: g10/tdbio.c:504
#, c-format
msgid "%s: can't open: %s\n"
msgstr "%s: ÎÅ×ÏÚÍÏÖÎÏ ÏÔËÒÙÔØ: %s\n"
#: g10/encode.c:107
#, c-format
msgid "error creating passphrase: %s\n"
msgstr "ÏÛÉÂËÁ ÐÒÉ ÓÏÚÄÁÎÉÉ ËÌÀÞÅ×ÏÊ ÆÒÁÚÙ: %s\n"
#: g10/encode.c:155 g10/encode.c:269
#, fuzzy, c-format
msgid "%s: WARNING: empty file\n"
msgstr "%s: ÐÒÅÄÕÐÒÅÖÄÅÎÉÅ: ÐÕÓÔÏÊ ÆÁÊÌ.\n"
#: g10/encode.c:222
#, c-format
msgid "reading from '%s'\n"
msgstr "þÉÔÁÅÔÓÑ ÉÚ '%s'\n"
#: g10/encode.c:397
#, fuzzy, c-format
msgid "%s/%s encrypted for: %s\n"
msgstr "%s ÚÁÛÉÆÒÏ×ÁÎÏ ÄÌÑ: %s\n"
#: g10/export.c:114
#, fuzzy, c-format
msgid "%s: user not found: %s\n"
msgstr "%s: ÐÏÌØÚÏ×ÁÔÅÌØ ÎÅ ÎÁÊÄÅÎ\n"
#: g10/export.c:123
#, c-format
msgid "certificate read problem: %s\n"
msgstr ""
#: g10/export.c:132
#, fuzzy, c-format
msgid "key %08lX: not a rfc2440 key - skipped\n"
msgstr "ÓÅËÒÅÔÎÙÊ ËÌÀÞ %08lX: ÎÅ ÉÍÅÅÔ ÓÏÏÔ×ÅÔÓÔ×ÕÀÝÅÇÏ ÏÔËÒÙÔÏÇÏ ËÌÀÞÁ.\n"
#: g10/export.c:174
#, fuzzy
msgid "WARNING: nothing exported\n"
msgstr "÷îéíáîéå: éÓÐÏÌØÚÕÅÔÓÑ ËÌÀÞ Ë ËÏÔÏÒÏÍÕ ÎÅÔ ÄÏ×ÅÒÉÑ!\n"
#: g10/getkey.c:164
msgid "too many entries in pk cache - disabled\n"
msgstr ""
#: g10/getkey.c:263
msgid "too many entries in unk cache - disabled\n"
msgstr ""
#: g10/getkey.c:989
#, c-format
msgid "using secondary key %08lX instead of primary key %08lX\n"
msgstr "ÉÓÐÏÌØÚÕÅÔÓÑ ÄÏÐÏÌÎÉÔÅÌØÎÙÊ ËÌÀÞ %09lX ×ÍÅÓÔÏ ÏÓÎÏ×ÎÏÇÏ %08lX%\n"
#: g10/import.c:129 g10/trustdb.c:1166
#, c-format
msgid "can't open file: %s\n"
msgstr "ÎÅ×ÏÚÍÏÖÎÏ ÏÔËÒÙÔØ ÆÁÊÌ: %s\n"
#: g10/import.c:145
#, c-format
msgid "skipping block of type %d\n"
msgstr "ÐÒÏÐÕÓËÁÅÍ ÂÌÏË ÔÉÐÁ %d\n"
#: g10/import.c:152 g10/trustdb.c:1425 g10/trustdb.c:1494
#, c-format
msgid "%lu keys so far processed\n"
msgstr ""
#: g10/import.c:157 g10/trustdb.c:1242
#, c-format
msgid "read error: %s\n"
msgstr "ÏÛÉÂËÁ ÞÔÅÎÉÑ: %s\n"
#: g10/import.c:159
#, c-format
msgid "Total number processed: %lu\n"
msgstr ""
#: g10/import.c:161
#, c-format
msgid " w/o user IDs: %lu\n"
msgstr ""
#: g10/import.c:163
#, c-format
msgid " imported: %lu"
msgstr ""
#: g10/import.c:169
#, c-format
msgid " unchanged: %lu\n"
msgstr ""
#: g10/import.c:171
#, c-format
msgid " new user IDs: %lu\n"
msgstr ""
#: g10/import.c:173
#, c-format
msgid " new subkeys: %lu\n"
msgstr ""
#: g10/import.c:175
#, fuzzy, c-format
msgid " new signatures: %lu\n"
msgstr "ËÌÀÞ %08lX: %d ÎÏ×ÙÈ ÐÏÄÐÉÓÅÊ\n"
#: g10/import.c:177
#, c-format
msgid " new key revocations: %lu\n"
msgstr ""
#: g10/import.c:179
#, c-format
msgid " secret keys read: %lu\n"
msgstr ""
#: g10/import.c:181
#, fuzzy, c-format
msgid " secret keys imported: %lu\n"
msgstr "ËÌÀÞ %08lX: ÓÅËÒÅÔÎÙÊ ËÌÀÞ ÉÍÐÏÒÔÉÒÏ×ÁÎ\n"
#: g10/import.c:183
#, fuzzy, c-format
msgid " secret keys unchanged: %lu\n"
msgstr "éÓÐÏÌØÚÏ×ÁÎ ÎÅÐÒÁ×ÉÌØÎÙÊ ÓÅËÒÅÔÎÙÊ ËÌÀÞ"
#: g10/import.c:325 g10/import.c:517
#, c-format
msgid "key %08lX: no user id\n"
msgstr "ËÌÀÞ %08lX: ÎÅÔ ÉÄÅÎÔÉÆÉËÁÔÏÒÁ ÐÏÌØÚÏ×ÁÔÅÌÑ\n"
#: g10/import.c:336
#, c-format
msgid "key %08lX: no valid user ids\n"
msgstr "ËÌÀÞ %08lX: ÎÅÔ ÄÏÐÕÓÔÉÍÙÈ ÉÄÅÎÔÉÆÉËÁÔÏÒÏ× ÐÏÌØÚÏ×ÁÔÅÌÅÊ\n"
#: g10/import.c:338
msgid "this may be caused by a missing self-signature\n"
msgstr "ÜÔÏ ÍÏÖÅÔ ÂÙÔØ ×ÙÚ×ÁÎÏ ÏÔÓÕÔÓÔ×ÉÅÍ ÓÁÍÏ-ÐÏÄÐÉÓÉ\n"
#: g10/import.c:349 g10/import.c:585
#, c-format
msgid "key %08lX: public key not found: %s\n"
msgstr "ËÌÀÞ %08lX: ÏÔËÒÙÔÙÊ ËÌÀÞ ÎÅ ÎÁÊÄÅÎ: %s\n"
#: g10/import.c:355
msgid "no default public keyring\n"
msgstr "ÎÅÔ Ó×ÑÚËÉ ÏÔËÒÙÔÙÈ ËÌÀÞÅÊ ÐÏ ÕÍÏÌÞÁÎÉÀ\n"
#: g10/import.c:359 g10/openfile.c:105 g10/sign.c:205 g10/sign.c:569
#, c-format
msgid "writing to '%s'\n"
msgstr "ÚÁÐÉÓÙ×ÁÅÔÓÑ × '%s'\n"
#: g10/import.c:363 g10/import.c:423 g10/import.c:639
#, c-format
msgid "can't lock public keyring: %s\n"
msgstr "ÎÅ×ÏÚÍÏÖÎÏ ÚÁÂÌÏËÉÒÏ×ÁÔØ Ó×ÑÚËÕ ÏÔËÒÙÔÙÈ ËÌÀÞÅÊ: %s\n"
#: g10/import.c:366
#, c-format
msgid "can't write to keyring: %s\n"
msgstr "ÎÅ×ÏÚÍÏÖÎÏ ÚÁÐÉÓÁÔØ × Ó×ÑÚËÕ ËÌÀÞÅÊ: %s\n"
#: g10/import.c:370
#, c-format
msgid "key %08lX: public key imported\n"
msgstr "ËÌÀÞ %08lX: ÏÔËÒÙÔÙÊ ËÌÀÞ ÉÍÐÏÒÔÉÒÏ×ÁÎ\n"
#: g10/import.c:383
#, c-format
msgid "key %08lX: doesn't match our copy\n"
msgstr "ËÌÀÞ %08lX: ÎÅ ÓÏ×ÐÁÄÁÅÔ Ó ÎÁÛÅÊ ËÏÐÉÅÊ\n"
#: g10/import.c:396 g10/import.c:594
#, c-format
msgid "key %08lX: can't locate original keyblock: %s\n"
msgstr "ËÌÀÞ %08lX: ÎÅ×ÏÚÍÏÖÎÏ ÏÂÎÁÒÕÖÉÔØ original keyblock: %s\n"
#: g10/import.c:403 g10/import.c:601
#, c-format
msgid "key %08lX: can't read original keyblock: %s\n"
msgstr "ËÌÀÞ %08lX: ÎÅ×ÏÚÍÏÖÎÏ ÐÒÏÞÉÔÁÔØ original keyblock: %s\n"
#: g10/import.c:420 g10/import.c:532 g10/import.c:636
msgid "writing keyblock\n"
msgstr "ÚÁÐÉÓÙ×ÁÅÔÓÑ ÂÌÏË ËÌÀÞÁ\n"
#: g10/import.c:426 g10/import.c:642
#, c-format
msgid "can't write keyblock: %s\n"
msgstr "ÎÅ×ÏÚÍÏÖÎÏ ÚÁÐÉÓÁÔØ ÂÌÏË ËÌÀÞÁ: %s\n"
#: g10/import.c:431
#, c-format
msgid "key %08lX: 1 new user-id\n"
msgstr "ËÌÀÞ %08lX: 1 ÎÏ×ÙÊ ÉÄÅÎÔÉÆÉËÁÔÏÒ ÐÏÌØÚÏ×ÁÔÅÌÑ\n"
#: g10/import.c:434
#, c-format
msgid "key %08lX: %d new user-ids\n"
msgstr "ËÌÀÞ %08lX: %d ÎÏ×ÙÈ ÉÄÅÎÔÉÆÉËÁÔÏÒÏ× ÐÏÌØÚÏ×ÁÔÅÌÅÊ\n"
#: g10/import.c:437
#, c-format
msgid "key %08lX: 1 new signature\n"
msgstr "ËÌÀÞ %08lX: 1 ÎÏ×ÁÑ ÐÏÄÐÉÓØ\n"
#: g10/import.c:440
#, c-format
msgid "key %08lX: %d new signatures\n"
msgstr "ËÌÀÞ %08lX: %d ÎÏ×ÙÈ ÐÏÄÐÉÓÅÊ\n"
#: g10/import.c:443
#, c-format
msgid "key %08lX: 1 new subkey\n"
msgstr "ËÌÀÞ %08lX: 1 ÎÏ×ÙÊ ÐÏÄ-ËÌÀÞ\n"
#: g10/import.c:446
#, c-format
msgid "key %08lX: %d new subkeys\n"
msgstr "ËÌÀÞ %08lX: %d ÎÏ×ÙÈ ÐÏÄ-ËÌÀÞÅÊ\n"
#: g10/import.c:456
#, c-format
msgid "key %08lX: not changed\n"
msgstr "ËÌÀÞ %08lX: ÎÅ ÉÚÍÅÎÅÎ\n"
#: g10/import.c:535
#, c-format
msgid "can't lock secret keyring: %s\n"
msgstr "ÎÅ×ÏÚÍÏÖÎÏ ÚÁÂÌÏËÉÒÏ×ÁÔØ Ó×ÑÚËÕ ÓÅËÒÅÔÎÙÈ ËÌÀÞÅÊ: %s\n"
#: g10/import.c:538
#, fuzzy, c-format
msgid "can't write keyring: %s\n"
msgstr "ÎÅ×ÏÚÍÏÖÎÏ ÚÁÐÉÓÁÔØ Ó×ÑÚËÕ ËÌÀÞÅÊ: %s\n"
#. we are ready
#: g10/import.c:541
#, c-format
msgid "key %08lX: secret key imported\n"
msgstr "ËÌÀÞ %08lX: ÓÅËÒÅÔÎÙÊ ËÌÀÞ ÉÍÐÏÒÔÉÒÏ×ÁÎ\n"
#. we can't merge secret keys
#: g10/import.c:545
#, c-format
msgid "key %08lX: already in secret keyring\n"
msgstr "ËÌÀÞ %08lX: ÕÖÅ ÎÁ Ó×ÑÚËÅ ÓÅËÒÅÔÎÙÈ ËÌÀÞÅÊ\n"
#: g10/import.c:550
#, c-format
msgid "key %08lX: secret key not found: %s\n"
msgstr "ËÌÀÞ %08lX: ÓÅËÒÅÔÎÙÊ ËÌÀÞ ÎÅ ÎÁÊÄÅÎ: %s\n"
#: g10/import.c:579
#, c-format
msgid "key %08lX: no public key - can't apply revocation certificate\n"
msgstr ""
"ËÌÀÞ %08lX: ÎÅÔ ÏÔËÒÙÔÏÇÏ ËÌÀÞÁ - ÎÅ×ÏÚÍÏÖÎÏ ÐÒÉÍÅÎÉÔØ ÏÔÚÙ×ÁÀÝÉÊ "
"ÓÅÒÔÉÆÉËÁÔ\n"
#: g10/import.c:612
#, c-format
msgid "key %08lX: invalid revocation certificate: %s - rejected\n"
msgstr "ËÌÀÞ %08lX: ÎÅÄÏÐÕÓÔÉÍÙÊ ÏÔÚÙ×ÁÀÝÉÊ ÓÅÒÔÉÆÉËÁÔ: %s - ÏÔ×ÅÒÇÎÕÔ\n"
#: g10/import.c:646
#, c-format
msgid "key %08lX: revocation certificate imported\n"
msgstr "ËÌÀÞ %08lX: ÏÔÚÙ×ÁÀÝÉÊ ÓÅÒÔÉÆÉËÁÔ ÉÍÐÏÒÔÉÒÏ×ÁÎ\n"
#: g10/import.c:677
#, c-format
msgid "key %08lX: no user-id for signature\n"
msgstr "ËÌÀÞ %08lX: ÎÅÔ ÉÄÅÎÔÉÆÉËÁÔÏÒÁ ÐÏÌØÚÏ×ÁÔÅÌÑ ÄÌÑ ÐÏÄÐÉÓÉ\n"
#: g10/import.c:684
#, c-format
msgid "key %08lX: unsupported public key algorithm\n"
msgstr "ËÌÀÞ %08lX: ÎÅÐÏÄÄÅÒÖÉ×ÁÅÍÙÊ ÁÌÇÏÒÉÔÍ ÏÔËÒÙÔÏÇÏ ËÌÀÞÁ\n"
#: g10/import.c:685
#, c-format
msgid "key %08lX: invalid self-signature\n"
msgstr "ËÌÀÞ %08lX: ÎÅÄÏÐÕÓÔÉÍÁÑ ÓÁÍÏ-ÐÏÄÐÉÓØ\n"
#: g10/import.c:714
#, c-format
msgid "key %08lX: skipped userid '"
msgstr "ËÌÀÞ %08lX: ÐÒÏÐÕÝÅÎ ÉÄÅÎÔÉÆÉËÁÔÏÒ ÐÏÌØÚÏ×ÁÔÅÌÑ '"
#: g10/import.c:737
#, c-format
msgid "key %08lX: revocation certificate at wrong place - skipped\n"
msgstr "ËÌÀÞ %08lX: ÏÔÚÙ×ÁÀÝÉÊ ÓÅÒÔÉÆÉËÁÔ × ÎÅÐÒÁ×ÉÌØÎÏÍ ÍÅÓÔÅ - ÐÒÏÐÕÝÅÎ\n"
#: g10/import.c:745
#, c-format
msgid "key %08lX: invalid revocation certificate: %s - skipped\n"
msgstr "ËÌÀÞ %08lX: ÎÅÄÏÐÕÓÔÉÍÙÊ ÏÔÚÙ×ÁÀÝÉÊ ÓÅÒÔÉÆÉËÁÔ: %s - ÐÒÏÐÕÝÅÎ\n"
#: g10/import.c:804
#, c-format
msgid "key %08lX: revocation certificate added\n"
msgstr "ËÌÀÞ %08lX: ÏÔÚÙ×ÁÀÝÉÊ ÓÅÒÔÉÆÉËÁÔ ÄÏÂÁ×ÌÅÎ\n"
#: g10/import.c:918 g10/import.c:973
#, c-format
msgid "key %08lX: our copy has no self-signature\n"
msgstr "ËÌÀÞ %08lX: ÎÁÛÁ ËÏÐÉÑ ÎÅ ÉÍÅÅÔ ÓÁÍÏ-ÐÏÄÐÉÓÉ\n"
#: g10/keyedit.c:81
#, c-format
msgid "%s: user not found\n"
msgstr "%s: ÐÏÌØÚÏ×ÁÔÅÌØ ÎÅ ÎÁÊÄÅÎ\n"
#: g10/keyedit.c:164
#, fuzzy
msgid "[self-signature]"
msgstr "[ÓÁÍÏ-ÐÏÄÐÉÓØ]\n"
#: g10/keyedit.c:182
#, fuzzy
msgid "1 bad signature\n"
msgstr "1 ÐÌÏÈÁÑ ÐÏÄÐÉÓØ\n"
#: g10/keyedit.c:184
#, c-format
msgid "%d bad signatures\n"
msgstr "%d ÐÌÏÈÉÈ ÐÏÄÐÉÓÅÊ\n"
#: g10/keyedit.c:186
#, fuzzy
msgid "1 signature not checked due to a missing key\n"
msgstr "1 ÐÏÄÐÉÓØ ÎÅ ÐÒÏ×ÅÒÅÎÁ ÉÚ-ÚÁ ÏÔÓÕÔÓÔ×ÉÑ ËÌÀÞÁ\n"
#: g10/keyedit.c:188
#, fuzzy, c-format
msgid "%d signatures not checked due to missing keys\n"
msgstr "%s ÐÏÄÐÉÓÅÊ ÎÅ ÐÒÏ×ÅÒÅÎÏ ÉÚ-ÚÁ ÏÔÓÕÔÓÔ×ÉÑ ËÌÀÞÅÊ\n"
#: g10/keyedit.c:190
#, fuzzy
msgid "1 signature not checked due to an error\n"
msgstr "1 ÐÏÄÐÉÓØ ÎÅ ÐÒÏ×ÅÒÅÎÁ ÉÚ-ÚÁ ÏÛÉÂËÉ\n"
#: g10/keyedit.c:192
#, c-format
msgid "%d signatures not checked due to errors\n"
msgstr "%s ÐÏÄÐÉÓÅÊ ÎÅ ÐÒÏ×ÅÒÅÎÏ ÉÚ-ÚÁ ÏÛÉÂÏË\n"
#: g10/keyedit.c:194
#, fuzzy
msgid "1 user id without valid self-signature detected\n"
msgstr "ÏÂÎÁÒÕÖÅÎ 1 ÉÄÅÎÔÉÆÉËÁÔÏÒ ÐÏÌØÚÏ×ÁÔÅÌÑ ÂÅÚ ÄÏÐÕÓÔÉÍÏÊ ÓÁÍÏ-ÐÏÄÐÉÓÉ\n"
#: g10/keyedit.c:196
#, c-format
msgid "%d user ids without valid self-signatures detected\n"
msgstr ""
"ÏÂÎÁÒÕÖÅÎÏ %d ÉÄÅÎÔÉÆÉËÁÔÏÒÏ× ÐÏÌØÚÏ×ÁÔÅÌÅÊ ÂÅÚ ÄÏÐÕÓÔÉÍÙÈ ÓÁÍÏ-ÐÏÄÐÉÓÅÊ\n"
#: g10/keyedit.c:258
#, fuzzy, c-format
msgid "Already signed by key %08lX\n"
msgstr "õÖÅ ÐÏÄÐÉÓÁÎÏ ËÌÀÞÏÍ %08lX.\n"
#: g10/keyedit.c:266
#, fuzzy, c-format
msgid "Nothing to sign with key %08lX\n"
msgstr "îÅÞÅÇÏ ÐÏÄÐÉÓÙ×ÁÔØ ËÌÀÞÁÍ %08lX\n"
#: g10/keyedit.c:275
#, fuzzy
msgid ""
"Are you really sure that you want to sign this key\n"
"with your key: \""
msgstr "÷Ù ÄÅÊÓÔ×ÉÔÅÌØÎÏ Õ×ÅÒÅÎÙ, ÞÔÏ ÈÏÔÉÔÅ ÐÏÄÐÉÓÁÔØ ÜÔÏÔ ËÌÀÞ Ó×ÏÉÍ:\n"
#: g10/keyedit.c:282
msgid "Really sign? "
msgstr "äÅÊÓÔ×ÉÔÅÌØÎÏ ÐÏÄÐÉÓÁÔØ? "
#: g10/keyedit.c:303 g10/sign.c:65
#, fuzzy, c-format
msgid "signing failed: %s\n"
msgstr "ÏÛÉÂËÁ ÐÏÄÐÉÓÙ×ÁÎÉÑ: %s\n"
#: g10/keyedit.c:356
msgid "This key is not protected.\n"
msgstr "üÔÏÔ ËÌÀÞ ÎÅ ÚÁÝÉÝÅÎ.\n"
#: g10/keyedit.c:359
msgid "Key is protected.\n"
msgstr "üÔÏÔ ËÌÀÞ ÚÁÝÉÝÅÎ.\n"
#: g10/keyedit.c:376
#, c-format
msgid "Can't edit this key: %s\n"
msgstr "îÅ×ÏÚÍÏÖÎÏ ÒÅÄÁËÔÉÒÏ×ÁÔØ ÜÔÏÔ ËÌÀÞ: %s\n"
#: g10/keyedit.c:381
msgid ""
"Enter the new passphrase for this secret key.\n"
"\n"
msgstr ""
"÷×ÅÄÉÔÅ ÎÏ×ÕÀ ËÌÀÞÅ×ÕÀ ÆÒÁÚÕ ÄÌÑ ÜÔÏÇÏ ÓÅËÒÅÔÎÏÇÏ ËÌÀÞÁ.\n"
"\n"
#: g10/keyedit.c:393
msgid ""
"You don't want a passphrase - this is probably a *bad* idea!\n"
"\n"
msgstr ""
"÷Ù ÎÅ ÈÏÔÉÔÅ ËÌÀÞÅ×ÕÀ ÆÒÁÚÕ - ÜÔÏ ÓËÏÒÅÅ ×ÓÅÇÏ *ÐÌÏÈÁÑ* ÉÄÅÑ!\n"
"\n"
#: g10/keyedit.c:396
msgid "Do you really want to do this? "
msgstr "÷Ù ÄÅÊÓÔ×ÉÔÅÌØÎÏ ÜÔÏÇÏ ÈÏÔÉÔÅ? "
#: g10/keyedit.c:455
msgid "moving a key signature to the correct place\n"
msgstr ""
#: g10/keyedit.c:490
msgid "quit"
msgstr "×ÙÈÏÄ"
#: g10/keyedit.c:490
msgid "quit this menu"
msgstr "×ÙÊÔÉ ÉÚ ÍÅÎÀ"
#: g10/keyedit.c:491
msgid "q"
msgstr ""
#: g10/keyedit.c:492
msgid "save"
msgstr "ÚÁÐÉÓÁÔØ"
#: g10/keyedit.c:492
msgid "save and quit"
msgstr "ÚÁÐÉÓÁÔØ É ×ÙÊÔÉ"
#: g10/keyedit.c:493
msgid "help"
msgstr "ÐÏÍÏÝØ"
#: g10/keyedit.c:493
msgid "show this help"
msgstr "ÐÏËÁÚÁÔØ ÐÏÍÏÝØ"
#: g10/keyedit.c:495
msgid "fpr"
msgstr ""
#: g10/keyedit.c:495
#, fuzzy
msgid "show fingerprint"
msgstr "ÐÏËÁÚÁÔØ \"ÏÔÐÅÞÁÔÏË ÐÁÌØÃÁ\""
#: g10/keyedit.c:496
#, fuzzy
msgid "list"
msgstr "ÓÐÉÓÏË"
#: g10/keyedit.c:496
#, fuzzy
msgid "list key and user ids"
msgstr "ÓÐÉÓÏË ËÌÀÞÅÊ É ÉÄÅÎÔÉÆÉËÁÔÏÒÏ× ÐÏÌØÚÏ×ÁÔÅÌÅÊ"
#: g10/keyedit.c:497
msgid "l"
msgstr ""
#: g10/keyedit.c:498
msgid "uid"
msgstr ""
#: g10/keyedit.c:498
msgid "select user id N"
msgstr "×ÙÂÒÁÔØ ÉÄÅÎÔÉÆÉËÁÔÏÒ ÐÏÌØÚÏ×ÁÔÅÌÑ N"
#: g10/keyedit.c:499
msgid "key"
msgstr "ËÌÀÞ"
#: g10/keyedit.c:499
msgid "select secondary key N"
msgstr "×ÙÂÒÁÔØ ÄÏÐÏÌÎÉÔÅÌØÎÙÊ ËÌÀÞ N"
#: g10/keyedit.c:500
msgid "check"
msgstr "ÐÒÏ×ÅÒËÁ"
#: g10/keyedit.c:500
#, fuzzy
msgid "list signatures"
msgstr "ÓÐÉÓÏË ËÌÀÞÅÊ É ÉÈ ÐÏÄÐÉÓÅÊ"
#: g10/keyedit.c:501
msgid "c"
msgstr ""
#: g10/keyedit.c:502
msgid "sign"
msgstr "ÐÏÄÐÉÓÁÔØ"
#: g10/keyedit.c:502
#, fuzzy
msgid "sign the key"
msgstr "ÐÏÄÐÉÓÁÔØ ËÌÀÞ"
#: g10/keyedit.c:503
msgid "s"
msgstr ""
#: g10/keyedit.c:504
msgid "debug"
msgstr "ÏÔÌÁÄËÁ"
#: g10/keyedit.c:505
msgid "adduid"
msgstr ""
#: g10/keyedit.c:505
msgid "add a user id"
msgstr "ÄÏÂÁ×ÉÔØ ÉÄÅÎÔÉÆÉËÁÔÏÒ ÐÏÌØÚÏ×ÁÔÅÌÑ"
#: g10/keyedit.c:506
msgid "deluid"
msgstr ""
#: g10/keyedit.c:506
#, fuzzy
msgid "delete user id"
msgstr "ÕÄÁÌÉÔØ ÉÄÅÎÔÉÆÉËÁÔÏÒ ÐÏÌØÚÏ×ÁÔÅÌÑ"
#: g10/keyedit.c:507
msgid "addkey"
msgstr ""
#: g10/keyedit.c:507
#, fuzzy
msgid "add a secondary key"
msgstr "ÄÏÂÁ×ÉÔØ ÄÏÐÏÌÎÉÔÅÌØÎÙÊ ËÌÀÞ"
#: g10/keyedit.c:508
msgid "delkey"
msgstr ""
#: g10/keyedit.c:508
msgid "delete a secondary key"
msgstr "ÕÄÁÌÉÔØ ÄÏÐÏÌÎÉÔÅÌØÎÙÊ ËÌÀÞ"
#: g10/keyedit.c:509
msgid "expire"
msgstr ""
#: g10/keyedit.c:509
#, fuzzy
msgid "change the expire date"
msgstr "ÉÚÍÅÎÉÔØ ËÌÀÞÅ×ÕÀ ÆÒÁÚÕ"
#: g10/keyedit.c:510
msgid "toggle"
msgstr ""
#: g10/keyedit.c:510
msgid "toggle between secret and public key listing"
msgstr "ÐÅÒÅËÌÀÞÉÔØ ÍÅÖÄÕ ÓÐÉÓËÏÍ ÓÅËÒÅÔÎÙÈ É ÏÔËÒÙÔÙÈ ËÌÀÞÅÊ"
#: g10/keyedit.c:512
msgid "t"
msgstr ""
#: g10/keyedit.c:513
msgid "pref"
msgstr ""
#: g10/keyedit.c:513
msgid "list preferences"
msgstr ""
#: g10/keyedit.c:514
msgid "passwd"
msgstr ""
#: g10/keyedit.c:514
#, fuzzy
msgid "change the passphrase"
msgstr "ÉÚÍÅÎÉÔØ ËÌÀÞÅ×ÕÀ ÆÒÁÚÕ"
#: g10/keyedit.c:515
msgid "trust"
msgstr ""
#: g10/keyedit.c:515
msgid "change the ownertrust"
msgstr "ÉÚÍÅÎÉÔØ ÐÁÒÁÍÅÔÒÙ ÄÏ×ÅÒÉÑ"
#: g10/keyedit.c:534
msgid "can't do that in batchmode\n"
msgstr "ÎÅ×ÏÚÍÏÖÎÏ ÓÄÅÌÁÔØ ÜÔÏ × ÐÁËÅÔÎÏÍ ÒÅÖÉÍÅ.\n"
#. check that they match
#. FIXME: check that they both match
#: g10/keyedit.c:561
#, fuzzy
msgid "Secret key is available.\n"
msgstr "éÍÅÅÔÓÑ ÓÅËÒÅÔÎÙÊ ËÌÀÞ.\n"
#: g10/keyedit.c:590
#, fuzzy
msgid "Command> "
msgstr "ëÏÍÁÎÄÁ> "
#: g10/keyedit.c:617
#, fuzzy
msgid "Need the secret key to do this.\n"
msgstr "þÔÏÂÙ ÜÔÏ ÓÄÅÌÁÔØ, ÎÕÖÅÎ ÓÅËÒÅÔÎÙÊ ËÌÀÞ.\n"
#: g10/keyedit.c:639
msgid "Save changes? "
msgstr "óÏÈÒÁÎÉÔØ ÉÚÍÅÎÅÎÉÑ? "
#: g10/keyedit.c:642
msgid "Quit without saving? "
msgstr "÷ÙÊÔÉ ÂÅÚ ÓÏÈÒÁÎÅÎÉÑ? "
#: g10/keyedit.c:652
#, fuzzy, c-format
msgid "update failed: %s\n"
msgstr "ÏÂÎÏ×ÌÅÎÉÅ ÎÅ ÕÄÁÌÏÓØ: %s\n"
#: g10/keyedit.c:659
#, fuzzy, c-format
msgid "update secret failed: %s\n"
msgstr "ÏÂÎÏ×ÌÅÎÉÅ ÓÅËÒÅÔÁ ÎÅ ÕÄÁÌÏÓØ: %s\n"
#: g10/keyedit.c:666
msgid "Key not changed so no update needed.\n"
msgstr "ëÌÀÞ ÎÅ ÉÚÍÅÎÉÌÓÑ, ÏÂÎÏ×ÌÅÎÉÅ ÎÅ ÎÕÖÎÏ.\n"
#: g10/keyedit.c:669 g10/keyedit.c:727
#, fuzzy, c-format
msgid "update of trust db failed: %s\n"
msgstr "ÏÂÎÏ×ÌÅÎÉÅ ÂÁÚÙ ÄÁÎÎÙÈ ÄÏ×ÅÒÉÑ ÎÅ ÕÄÁÌÏÓØ: %s\n"
#: g10/keyedit.c:701
msgid "Really sign all user ids? "
msgstr "äÅÊÓÔ×ÉÔÅÌØÎÏ ÐÏÄÐÉÓÁÔØ ×ÓÅ ÉÄÅÎÔÉÆÉËÁÔÏÒÙ ÐÏÌØÚÏ×ÁÔÅÌÑ? "
#: g10/keyedit.c:702
msgid "Hint: Select the user ids to sign\n"
msgstr ""
"ðÏÄÓËÁÚËÁ: ×ÙÂÅÒÉÔÅ ÉÄÅÎÔÉÆÉËÁÔÏÒÙ ÐÏÌØÚÏ×ÁÔÅÌÑ ËÏÔÏÒÙÅ ÈÏÔÉÔÅ ÐÏÄÐÉÓÁÔØ\n"
#: g10/keyedit.c:738
msgid "You must select at least one user id.\n"
msgstr "÷Ù ÄÏÌÖÎÙ ×ÙÂÒÁÔØ ÈÏÔÑ ÂÙ ÏÄÉÎ ÉÄÅÎÔÉÆÉËÁÔÏÒ ÐÏÌØÚÏ×ÁÔÅÌÑ.\n"
#: g10/keyedit.c:740
msgid "You can't delete the last user id!\n"
msgstr "÷Ù ÎÅ ÍÏÖÅÔÅ ÕÄÁÌÉÔØ ÐÏÓÌÅÄÎÉÊ ÉÄÅÎÔÉÆÉËÁÔÏÒ ÐÏÌØÚÏ×ÁÔÅÌÑ!\n"
#: g10/keyedit.c:743
#, fuzzy
msgid "Really remove all selected user ids? "
msgstr "äÅÊÓÔ×ÉÔÅÌØÎÏ ÕÄÁÌÉÔØ ×ÓÅ ×ÙÂÒÁÎÎÙÅ ÉÄÅÎÔÉÆÉËÁÔÏÒÙ ÐÏÌØÚÏ×ÁÔÅÌÑ? "
#: g10/keyedit.c:744
#, fuzzy
msgid "Really remove this user id? "
msgstr "äÅÊÓÔ×ÉÔÅÌØÎÏ ÕÄÁÌÉÔØ ÜÔÏÔ ÉÄÅÎÔÉÆÉËÁÔÏÒ ÐÏÌØÚÏ×ÁÔÅÌÑ? "
#: g10/keyedit.c:767
msgid "You must select at least one key.\n"
msgstr "÷Ù ÄÏÌÖÎÙ ×ÙÂÒÁÔØ ÈÏÔÑ ÂÙ ÏÄÉÎ ËÌÀÞ.\n"
#: g10/keyedit.c:771
#, fuzzy
msgid "Do you really want to delete the selected keys? "
msgstr "÷Ù ÄÅÊÓÔ×ÉÔÅÌØÎÏ ÈÏÔÉÔÅ ÕÄÁÌÉÔØ ×ÙÂÒÁÎÎÙÅ ËÌÀÞÉ? "
#: g10/keyedit.c:772
#, fuzzy
msgid "Do you really want to delete this key? "
msgstr "÷Ù ÄÅÊÓÔ×ÉÔÅÌØÎÏ ÈÏÔÉÔÅ ÕÄÁÌÉÔØ ÜÔÏÔ ËÌÀÞ? "
#: g10/keyedit.c:819
msgid "Invalid command (try \"help\")\n"
msgstr "îÅÄÏÐÕÓÔÉÍÁÑ ËÏÍÁÎÄÁ (ÐÏÐÒÏÂÕÊÔÅ \"help\")\n"
#: g10/keyedit.c:1197
msgid "Please remove selections from the secret keys.\n"
msgstr ""
#: g10/keyedit.c:1203
#, fuzzy
msgid "Please select at most one secondary key.\n"
msgstr "÷Ù ÄÏÌÖÎÙ ×ÙÂÒÁÔØ ÈÏÔÑ ÂÙ ÏÄÉÎ ËÌÀÞ.\n"
#: g10/keyedit.c:1207
msgid "Changing exiration time for a secondary key.\n"
msgstr ""
#: g10/keyedit.c:1209
msgid "Changing exiration time for the primary key.\n"
msgstr ""
#: g10/keyedit.c:1250
msgid "You can't change the expiration date of a v3 key\n"
msgstr ""
#: g10/keyedit.c:1266
msgid "No corresponding signature in secret ring\n"
msgstr ""
#: g10/keyedit.c:1326
#, c-format
msgid "No user id with index %d\n"
msgstr "îÅÔ ÉÄÅÎÔÉÆÉËÁÔÏÒÁ ÐÏÌØÚÏ×ÁÔÅÌÑ Ó ÉÎÄÅËÓÏÍ %d\n"
#: g10/keyedit.c:1371
#, c-format
msgid "No secondary key with index %d\n"
msgstr "îÅÔ ÄÏÐÏÌÎÉÔÅÌØÎÏÇÏ ËÌÀÞÁ Ó ÉÎÄÅËÓÏÍ %d\n"
#: g10/mainproc.c:198
#, fuzzy
msgid "public key encrypted data: Good DEK\n"
msgstr "ÒÁÓÛÉÆÒÏ×ËÁ ÏÔËÒÙÔÙÍ ËÌÀÞÏÍ ÎÅ ÕÄÁÌÁÓØ %s\n"
#: g10/mainproc.c:201
#, c-format
msgid "public key decryption failed: %s\n"
msgstr "ÒÁÓÛÉÆÒÏ×ËÁ ÏÔËÒÙÔÙÍ ËÌÀÞÏÍ ÎÅ ÕÄÁÌÁÓØ %s\n"
#: g10/mainproc.c:228
#, fuzzy
msgid "decryption okay\n"
msgstr "ÒÁÓÛÉÆÒÏ×ËÁ ÎÅ ÕÄÁÌÁÓØ: %s\n"
#: g10/mainproc.c:231
#, c-format
msgid "decryption failed: %s\n"
msgstr "ÒÁÓÛÉÆÒÏ×ËÁ ÎÅ ÕÄÁÌÁÓØ: %s\n"
#: g10/mainproc.c:248
#, fuzzy
msgid "NOTE: sender requested \"for-your-eyes-only\"\n"
msgstr "ÚÁÍÅÞÁÎÉÅ: ÏÔÐÒÁ×ÉÔÅÌØ ÚÁÐÒÏÓÉÌ \"ÔÏÌØËÏ-ÄÌÑ-÷ÁÛÉÈ-ÇÌÁÚ\"\n"
#: g10/mainproc.c:250
#, c-format
msgid "original file name='%.*s'\n"
msgstr ""
#: g10/mainproc.c:833
msgid "signature verification suppressed\n"
msgstr ""
#: g10/mainproc.c:839
#, c-format
msgid "Signature made %.*s using %s key ID %08lX\n"
msgstr "ðÏÄÐÉÓØ ÓÄÅÌÁÎÁ %.*s, ÉÓÐÏÌØÚÕÑ %s ËÌÀÞ %08lX\n"
#: g10/mainproc.c:847
msgid "BAD signature from \""
msgstr "ðìïèáñ ÐÏÄÐÉÓØ ÏÔ \""
#: g10/mainproc.c:848
msgid "Good signature from \""
msgstr "èÏÒÏÛÁÑ ÐÏÄÐÉÓØ ÏÔ \""
#: g10/mainproc.c:861
#, c-format
msgid "Can't check signature: %s\n"
msgstr "îÅ×ÏÚÍÏÖÎÏ ÐÒÏ×ÅÒÉÔØ ÐÏÄÐÉÓØ: %s\n"
#: g10/mainproc.c:934
msgid "old style (PGP 2.x) signature\n"
msgstr ""
#: g10/mainproc.c:939
msgid "invalid root packet detected in proc_tree()\n"
msgstr ""
#: g10/misc.c:88
#, fuzzy, c-format
msgid "can't disable core dumps: %s\n"
msgstr "ÎÅ×ÏÚÍÏÖÎÏ ÏÔËÒÙÔØ ÆÁÊÌ '%s': %s\n"
#: g10/misc.c:90
msgid "WARNING: Program may create a core file!\n"
msgstr ""
#: g10/misc.c:198
msgid "Experimental algorithms should not be used!\n"
msgstr ""
#: g10/misc.c:212
msgid ""
"RSA keys are deprecated; please consider creating a new key and use this key "
"in the future\n"
msgstr ""
"ðÏÌØÚÏ×ÁÎÉÅ RSA ËÌÀÞÁÍÉ ÎÅ ÒÅËÏÍÅÎÄÕÅÔÓÑ, ÐÏÖÁÌÕÊÓÔÁ, ÐÏÄÕÍÁÊÔÅ Ï ÓÏÚÄÁÎÉÉ\n"
"ÎÏ×ÏÇÏ ËÌÀÞÁ ÄÌÑ ÉÓÐÏÌØÚÏ×ÁÎÉÑ × ÂÕÄÕÝÅÍ\n"
#: g10/misc.c:233
msgid "This cipher algorithm is depreciated; please use a more standard one!\n"
msgstr ""
#: g10/parse-packet.c:109
#, fuzzy, c-format
msgid "can't handle public key algorithm %d\n"
msgstr "ÎÅ×ÏÚÍÏÖÎÏ ÚÁÂÌÏËÉÒÏ×ÁÔØ Ó×ÑÚËÕ ÏÔËÒÙÔÙÈ ËÌÀÞÅÊ: %s\n"
#: g10/passphrase.c:141
msgid ""
"\n"
"You need a passphrase to unlock the secret key for\n"
"user: \""
msgstr ""
"\n"
"÷ÁÍ ÎÕÖÎÁ ËÌÀÞÅ×ÁÑ ÆÒÁÚÁ, ÞÔÏÂÙ ÏÔÏÍËÎÕÔØ ËÌÀÞ\n"
"ÐÏÌØÚÏ×ÁÔÅÌÑ: \""
#: g10/passphrase.c:150
#, c-format
msgid "(%u-bit %s key, ID %08lX, created %s)\n"
msgstr "(%u-ÂÉÔ %s ËÌÀÞ, ID %08lX, ÓÏÚÄÁÎ %s)\n"
#: g10/passphrase.c:174
#, fuzzy
msgid "Enter passphrase: "
msgstr "÷×ÅÄÉÔÅ ËÌÀÞÅ×ÕÀ ÆÒÁÚÕ: %s\n"
#: g10/passphrase.c:178
#, fuzzy
msgid "Repeat passphrase: "
msgstr "ðÏ×ÔÏÒÉÔÅ ËÌÀÞÅ×ÕÀ ÆÒÁÚÕ: %s\n"
#: g10/plaintext.c:102
msgid "data not saved; use option \"--output\" to save it\n"
msgstr "ÄÁÎÎÙÅ ÎÅ ÂÙÌÉ ÓÏÈÒÁÎÅÎÙ; ×ÏÓÐÏÌØÚÕÊÔÅÓØ --\"output\" ÄÌÑ ÓÏÈÒÁÎÅÎÉÑ\n"
#: g10/plaintext.c:215
msgid "Please enter name of data file: "
msgstr "ðÏÖÁÌÕÊÓÔÁ, ××ÅÄÉÔÅ ÉÍÑ ÆÁÊÌÁ ÄÁÎÎÙÈ: "
#: g10/plaintext.c:236
msgid "reading stdin ...\n"
msgstr ""
#: g10/plaintext.c:299
#, c-format
msgid "can't open signed data '%s'\n"
msgstr "ÎÅ×ÏÚÍÏÖÎÏ ÏÔËÒÙÔØ ÐÏÄÐÉÓÁÎÎÙÅ ÄÁÎÎÙÅ '%s' .\n"
#: g10/pubkey-enc.c:78
#, c-format
msgid "anonymous receiver; trying secret key %08lX ...\n"
msgstr "ÁÎÏÎÉÍÎÙÊ ÐÏÌÕÞÁÔÅÌØ, ÐÒÏÂÕÅÍ ÓÅËÒÅÔÎÙÊ ËÌÀÞ %08lX ...\n"
#: g10/pubkey-enc.c:84
msgid "okay, we are the anonymous receiver.\n"
msgstr "ïË, ÍÙ -- ÁÎÏÎÉÍÎÙÊ ÐÏÌÕÞÁÔÅÌØ.\n"
#: g10/pubkey-enc.c:136
#, fuzzy
msgid "old encoding of the DEK is not supported\n"
msgstr "ÁÌÇÏÒÉÔÍ ÚÁÝÉÔÙ %d ÎÅ ÐÏÄÄÅÒÖÉ×ÁÅÔÓÑ\n"
#: g10/pubkey-enc.c:183
#, fuzzy, c-format
msgid "NOTE: cipher algorithm %d not found in preferences\n"
msgstr "ÚÁÍÅÞÁÎÉÅ: ÛÉÆÒÏ×ÁÌØÎÙÊ ÁÌÇÏÒÉÔÍ %d ÎÅ ÎÁÊÄÅÎ × ÐÒÅÄÐÏÞÔÅÎÉÑÈ\n"
#: g10/seckey-cert.c:56
#, fuzzy, c-format
msgid "protection algorithm %d is not supported\n"
msgstr "ÁÌÇÏÒÉÔÍ ÚÁÝÉÔÙ %d ÎÅ ÐÏÄÄÅÒÖÉ×ÁÅÔÓÑ\n"
#: g10/seckey-cert.c:169
msgid "Invalid passphrase; please try again ...\n"
msgstr "îÅÐÒÁ×ÉÌØÎÁÑ ËÌÀÞÅ×ÁÑ ÆÒÁÚÁ, ÐÏÐÒÏÂÕÊÔÅ ÓÎÏ×Á ...\n"
#: g10/seckey-cert.c:216
#, fuzzy
msgid "WARNING: Weak key detected - please change passphrase again.\n"
msgstr "ðÒÅÄÕÐÒÅÖÄÅÎÉÅ: ÏÂÎÁÒÕÖÅÎ ÓÌÁÂÙÊ ËÌÀÞ - ÓÍÅÎÉÔÅ ËÌÀÞÅ×ÕÀ ÆÒÁÚÕ.\n"
#: g10/sig-check.c:155
msgid ""
"this is a PGP generated ElGamal key which is NOT secure for signatures!\n"
msgstr "ÜÔÏÔ ElGamal ËÌÀÞ, ÓÏÚÄÁÎÎÙÊ PGP, ÎÅ ÎÁÄÅÖÅÎ ÄÌÑ ÓÏÚÄÁÎÉÑ ÐÏÄÐÉÓÅÊ!\n"
#: g10/sig-check.c:165
msgid "public key created in future (time warp or clock problem)\n"
msgstr ""
"ÏÔËÒÙÔÙÊ ËÌÀÞ ÓÇÅÎÅÒÉÒÏ×ÁÎ × ÂÕÄÕÝÅÍ (ÉÓËÒÉ×ÌÅÎÉÅ ×ÒÅÍÅÎÉ ÉÌÉ ÎÅÐÒÁ×ÉÌØÎÏ "
"ÕÓÔÁÎÏ×ÌÅÎÙ ÞÁÓÙ)\n"
#: g10/sig-check.c:170
#, fuzzy, c-format
msgid "NOTE: signature key expired %s\n"
msgstr "ÐÒÅÄÕÐÒÅÖÄÅÎÉÅ: ËÌÀÞ ÐÏÄÐÉÓÉ ÕÓÔÁÒÅÌ %s\n"
#: g10/sign.c:69
#, fuzzy, c-format
msgid "%s signature from: %s\n"
msgstr "ðìïèáñ ÐÏÄÐÉÓØ ÏÔ \""
#: g10/sign.c:200 g10/sign.c:564
#, fuzzy, c-format
msgid "can't create %s: %s\n"
msgstr "%s: ÎÅ×ÏÚÍÏÖÎÏ ÏÔËÒÙÔØ: %s\n"
#: g10/sign.c:296
#, fuzzy
msgid "signing:"
msgstr "ÐÏÄÐÉÓÁÔØ"
#: g10/sign.c:336
#, fuzzy, c-format
msgid "WARNING: '%s' is an empty file\n"
msgstr "%s: ÐÒÅÄÕÐÒÅÖÄÅÎÉÅ: ÐÕÓÔÏÊ ÆÁÊÌ.\n"
#: g10/tdbio.c:116 g10/tdbio.c:1413
#, fuzzy, c-format
msgid "trustdb rec %lu: lseek failed: %s\n"
msgstr "ÏÂÎÏ×ÌÅÎÉÅ ÓÅËÒÅÔÁ ÎÅ ÕÄÁÌÏÓØ: %s\n"
#: g10/tdbio.c:122 g10/tdbio.c:1420
#, c-format
msgid "trustdb rec %lu: write failed (n=%d): %s\n"
msgstr ""
#: g10/tdbio.c:232
msgid "trustdb transaction to large\n"
msgstr ""
#: g10/tdbio.c:402
#, fuzzy, c-format
msgid "%s: can't access: %s\n"
msgstr "%s: ÎÅ×ÏÚÍÏÖÎÏ ÏÔËÒÙÔØ: %s\n"
#: g10/ringedit.c:273 g10/tdbio.c:422
#, fuzzy, c-format
msgid "%s: can't create directory: %s\n"
msgstr "%s: ÎÅ×ÏÚÍÏÖÎÏ ÏÔËÒÙÔØ: %s\n"
#: g10/ringedit.c:279 g10/tdbio.c:425
#, fuzzy, c-format
msgid "%s: directory created\n"
msgstr "%s: ÎÅ×ÏÚÍÏÖÎÏ ÏÔËÒÙÔØ: %s\n"
#: g10/tdbio.c:429
#, c-format
msgid "%s: directory does not exist!\n"
msgstr ""
#: g10/openfile.c:101 g10/openfile.c:165 g10/ringedit.c:1256 g10/tdbio.c:435
#, fuzzy, c-format
msgid "%s: can't create: %s\n"
msgstr "%s: ÎÅ×ÏÚÍÏÖÎÏ ÏÔËÒÙÔØ: %s\n"
#: g10/tdbio.c:459
#, c-format
msgid "%s: failed to create version record: %s"
msgstr ""
#: g10/tdbio.c:463
#, c-format
msgid "%s: invalid trust-db created\n"
msgstr ""
#: g10/tdbio.c:465
#, fuzzy, c-format
msgid "%s: trust-db created\n"
msgstr "%s: ÎÅ×ÏÚÍÏÖÎÏ ÏÔËÒÙÔØ: %s\n"
#: g10/tdbio.c:506
#, c-format
msgid "%s: invalid trust-db\n"
msgstr ""
#: g10/tdbio.c:540
#, fuzzy, c-format
msgid "%s: failed to create hashtable: %s\n"
msgstr "%s: ÎÅ×ÏÚÍÏÖÎÏ ÏÔËÒÙÔØ: %s\n"
#: g10/tdbio.c:548
#, fuzzy, c-format
msgid "%s: error updating version record: %s\n"
msgstr "Fehler beim Erzeugen der \"Passphrase\": %s\n"
#: g10/tdbio.c:564 g10/tdbio.c:603 g10/tdbio.c:628 g10/tdbio.c:1346
#: g10/tdbio.c:1373
#, fuzzy, c-format
msgid "%s: error reading version record: %s\n"
msgstr "Fehler beim Erzeugen der \"Passphrase\": %s\n"
#: g10/tdbio.c:577
#, fuzzy, c-format
msgid "%s: error writing version record: %s\n"
msgstr "Fehler beim Erzeugen der \"Passphrase\": %s\n"
#: g10/tdbio.c:1053
#, fuzzy, c-format
msgid "trustdb: lseek failed: %s\n"
msgstr "ÏÂÎÏ×ÌÅÎÉÅ ÓÅËÒÅÔÁ ÎÅ ÕÄÁÌÏÓØ: %s\n"
#: g10/tdbio.c:1061
#, fuzzy, c-format
msgid "trustdb: read failed (n=%d): %s\n"
msgstr "ÏÂÎÏ×ÌÅÎÉÅ ÂÁÚÙ ÄÁÎÎÙÈ ÄÏ×ÅÒÉÑ ÎÅ ÕÄÁÌÏÓØ: %s\n"
#: g10/tdbio.c:1082
#, fuzzy, c-format
msgid "%s: not a trustdb file\n"
msgstr "ÏÂÎÏ×ÌÅÎÉÅ ÂÁÚÙ ÄÁÎÎÙÈ ÄÏ×ÅÒÉÑ ÎÅ ÕÄÁÌÏÓØ: %s\n"
#: g10/tdbio.c:1098
#, c-format
msgid "%s: version record with recnum %lu\n"
msgstr ""
#: g10/tdbio.c:1103
#, fuzzy, c-format
msgid "%s: invalid file version %d\n"
msgstr "ÎÅÄÏÐÕÓÔÉÍÏÅ ÎÁÞÁÌÏ ÔÅËÓÔÏ×ÏÊ ÐÏÄÐÉÓÉ\n"
#: g10/tdbio.c:1379
#, fuzzy, c-format
msgid "%s: error reading free record: %s\n"
msgstr "Fehler beim Erzeugen der \"Passphrase\": %s\n"
#: g10/tdbio.c:1387
#, fuzzy, c-format
msgid "%s: error writing dir record: %s\n"
msgstr "Fehler beim Erzeugen der \"Passphrase\": %s\n"
#: g10/tdbio.c:1397
#, c-format
msgid "%s: failed to zero a record: %s\n"
msgstr ""
#: g10/tdbio.c:1427
#, c-format
msgid "%s: failed to append a record: %s\n"
msgstr ""
#: g10/trustdb.c:134
msgid "The trust DB is corrupted; please run \"gpgm --fix-trust-db\".\n"
msgstr "âÁÚÁ ÄÁÎÎÙÈ ÄÏ×ÅÒÉÑ ÒÁÚÒÕÛÅÎÁ: ÚÁÐÕÓÔÉÔÅ \"gpgm --fix-trust-db\".\n"
#: g10/trustdb.c:147
#, c-format
msgid "trust record %lu, req type %d: read failed: %s\n"
msgstr ""
#: g10/trustdb.c:162
#, c-format
msgid "trust record %lu, type %d: write failed: %s\n"
msgstr ""
#: g10/trustdb.c:176
#, fuzzy, c-format
msgid "trust record %lu: delete failed: %s\n"
msgstr "ÏÂÎÏ×ÌÅÎÉÅ ÓÅËÒÅÔÁ ÎÅ ÕÄÁÌÏÓØ: %s\n"
#: g10/trustdb.c:190
#, fuzzy, c-format
msgid "trust db: sync failed: %s\n"
msgstr "ÏÂÎÏ×ÌÅÎÉÅ ÂÁÚÙ ÄÁÎÎÙÈ ÄÏ×ÅÒÉÑ ÎÅ ÕÄÁÌÏÓØ: %s\n"
#: g10/trustdb.c:319
#, fuzzy, c-format
msgid "error reading dir record for LID %lu: %s\n"
msgstr "Fehler beim Erzeugen der \"Passphrase\": %s\n"
#: g10/trustdb.c:326
#, c-format
msgid "lid %lu: expected dir record, got type %d\n"
msgstr ""
#: g10/trustdb.c:331
#, c-format
msgid "no primary key for LID %lu\n"
msgstr ""
#: g10/trustdb.c:336
#, fuzzy, c-format
msgid "error reading primary key for LID %lu: %s\n"
msgstr "Fehler beim Erzeugen der \"Passphrase\": %s\n"
#: g10/trustdb.c:412
#, c-format
msgid "chained sigrec %lu has a wrong owner\n"
msgstr ""
#: g10/trustdb.c:455
#, fuzzy, c-format
msgid "'%s' is not a valid long keyID\n"
msgstr "îÅÄÏÐÕÓÔÉÍÙÊ ÓÉÍ×ÏÌ × ËÏÍÍÅÎÔÁÒÉÉ.\n"
#: g10/trustdb.c:490
#, fuzzy, c-format
msgid "key %08lX: no public key for trusted key - skipped\n"
msgstr "ÓÅËÒÅÔÎÙÊ ËÌÀÞ %08lX: ÎÅ ÉÍÅÅÔ ÓÏÏÔ×ÅÔÓÔ×ÕÀÝÅÇÏ ÏÔËÒÙÔÏÇÏ ËÌÀÞÁ.\n"
#: g10/trustdb.c:499 g10/trustdb.c:557
#, fuzzy, c-format
msgid "key %08lX: can't put it into the trustdb\n"
msgstr "ËÌÀÞ %08lX.%lu: ÎÅ×ÏÚÍÏÖÎÏ ÐÏÌÏÖÉÔØ × ÂÁÚÕ ÄÁÎÎÙÈ ÄÏ×ÅÒÉÑ\n"
#: g10/trustdb.c:504 g10/trustdb.c:563
#, fuzzy, c-format
msgid "key %08lX: query record failed\n"
msgstr "ËÌÀÞ %08lX: ÚÁÐÒÏÓ ÚÁÐÉÓÉ ÎÅ ÕÄÁÌÓÑ\n"
#: g10/trustdb.c:509 g10/trustdb.c:572
#, fuzzy, c-format
msgid "key %08lX: already in trusted key table\n"
msgstr "ËÌÀÞ %08lX: ÕÖÅ ÎÁ Ó×ÑÚËÅ ÓÅËÒÅÔÎÙÈ ËÌÀÞÅÊ\n"
#: g10/trustdb.c:512 g10/trustdb.c:575
#, fuzzy, c-format
msgid "key %08lX: accepted as trusted key.\n"
msgstr "ËÌÀÞ %08lX: ÕÖÅ ÎÁ Ó×ÑÚËÅ ÓÅËÒÅÔÎÙÈ ËÌÀÞÅÊ\n"
#: g10/trustdb.c:528
#, fuzzy, c-format
msgid "NOTE: secret key %08lX is NOT protected.\n"
msgstr "üÔÏÔ ËÌÀÞ ÎÅ ÚÁÝÉÝÅÎ.\n"
#: g10/trustdb.c:540
#, fuzzy, c-format
msgid "key %08lX: secret key without public key - skipped\n"
msgstr "ÓÅËÒÅÔÎÙÊ ËÌÀÞ %08lX: ÎÅ ÉÍÅÅÔ ÓÏÏÔ×ÅÔÓÔ×ÕÀÝÅÇÏ ÏÔËÒÙÔÏÇÏ ËÌÀÞÁ.\n"
#: g10/trustdb.c:547
#, c-format
msgid "key %08lX: secret and public key don't match\n"
msgstr "ËÌÀÞ %08lX: ÓÅËÒÅÔÎÙÊ É ÏÔËÒÙÔÏÇÏ ËÌÀÞÉ ÎÅ ÓÏ×ÐÁÄÁÀÔ.\n"
#: g10/trustdb.c:583
#, fuzzy, c-format
msgid "enumerate secret keys failed: %s\n"
msgstr "ÏÂÎÏ×ÌÅÎÉÅ ÓÅËÒÅÔÁ ÎÅ ÕÄÁÌÏÓØ: %s\n"
#: g10/trustdb.c:766
#, fuzzy, c-format
msgid "lid %lu: read dir record failed: %s\n"
msgstr "ËÌÀÞ %08lX.%lu: ×ÓÔÁ×ËÁ ÄÏ×ÅÒÉÔÅÌØÎÏÊ ÚÁÐÉÓÉ ÎÅ ÕÄÁÌÁÓØ: %s\n"
#: g10/trustdb.c:775
#, fuzzy, c-format
msgid "lid %lu: read key record failed: %s\n"
msgstr "ËÌÀÞ %08lX.%lu: ×ÓÔÁ×ËÁ ÄÏ×ÅÒÉÔÅÌØÎÏÊ ÚÁÐÉÓÉ ÎÅ ÕÄÁÌÁÓØ: %s\n"
#: g10/trustdb.c:785
#, fuzzy, c-format
msgid "lid %lu: read uid record failed: %s\n"
msgstr "ËÌÀÞ %08lX.%lu: ×ÓÔÁ×ËÁ ÄÏ×ÅÒÉÔÅÌØÎÏÊ ÚÁÐÉÓÉ ÎÅ ÕÄÁÌÁÓØ: %s\n"
#: g10/trustdb.c:794
#, fuzzy, c-format
msgid "lid %lu: read pref record failed: %s\n"
msgstr "ËÌÀÞ %08lX.%lu: ×ÓÔÁ×ËÁ ÄÏ×ÅÒÉÔÅÌØÎÏÊ ÚÁÐÉÓÉ ÎÅ ÕÄÁÌÁÓØ: %s\n"
#: g10/trustdb.c:804
#, fuzzy, c-format
msgid "lid %lu: read sig record failed: %s\n"
msgstr "ËÌÀÞ %08lX.%lu: ×ÓÔÁ×ËÁ ÄÏ×ÅÒÉÔÅÌØÎÏÊ ÚÁÐÉÓÉ ÎÅ ÕÄÁÌÁÓØ: %s\n"
#: g10/trustdb.c:999
msgid "Ooops, no keys\n"
msgstr ""
#: g10/trustdb.c:1003
#, fuzzy
msgid "Ooops, no user ids\n"
msgstr "ÓÐÉÓÏË ËÌÀÞÅÊ É ÉÄÅÎÔÉÆÉËÁÔÏÒÏ× ÐÏÌØÚÏ×ÁÔÅÌÅÊ"
#: g10/trustdb.c:1074 g10/trustdb.c:1092
#, c-format
msgid "user '%s' read problem: %s\n"
msgstr ""
#: g10/trustdb.c:1077 g10/trustdb.c:1095
#, c-format
msgid "user '%s' list problem: %s\n"
msgstr ""
#: g10/trustdb.c:1085 g10/trustdb.c:1300
#, fuzzy, c-format
msgid "user '%s' not found: %s\n"
msgstr "%s: ÐÏÌØÚÏ×ÁÔÅÌØ ÎÅ ÎÁÊÄÅÎ\n"
#: g10/trustdb.c:1087 g10/trustdb.c:1302
#, c-format
msgid "problem finding '%s' in trustdb: %s\n"
msgstr ""
#: g10/trustdb.c:1090
#, c-format
msgid "user '%s' not in trustdb\n"
msgstr ""
#: g10/trustdb.c:1125
#, c-format
msgid ""
"# List of assigned trustvalues, created %s\n"
"# (Use \"gpgm --import-ownertrust\" to restore them)\n"
msgstr ""
#: g10/trustdb.c:1131
msgid "directory record w/o primary key\n"
msgstr ""
#: g10/trustdb.c:1138
#, fuzzy, c-format
msgid "error reading key record: %s\n"
msgstr "Fehler beim Erzeugen der \"Passphrase\": %s\n"
#: g10/trustdb.c:1178
-msgid "line to long\n"
+msgid "line too long\n"
msgstr ""
#: g10/trustdb.c:1186
msgid "error: missing colon\n"
msgstr ""
#: g10/trustdb.c:1191
#, fuzzy
msgid "error: invalid fingerprint\n"
msgstr "ÏÛÉÂËÁ × ÚÁ×ÅÒÛÁÀÝÅÊ ÓÔÒÏËÅ\n"
#: g10/trustdb.c:1195
#, fuzzy
msgid "error: no ownertrust value\n"
msgstr "ÜËÓÐÏÒÔÉÒÏ×ÁÔØ ÐÁÒÁÍÅÔÒÙ ÄÏ×ÅÒÉÑ\n"
#: g10/trustdb.c:1209
#, c-format
msgid "LID %lu: changing trust from %u to %u\n"
msgstr ""
#: g10/trustdb.c:1212
#, c-format
msgid "LID %lu: setting trust to %u\n"
msgstr ""
#: g10/trustdb.c:1220
msgid "key not in trustdb, searching ring.\n"
msgstr ""
#: g10/trustdb.c:1223
#, fuzzy, c-format
msgid "key not in ring: %s\n"
msgstr "ÎÅ×ÏÚÍÏÖÎÏ ÚÁÐÉÓÁÔØ Ó×ÑÚËÕ ËÌÀÞÅÊ: %s\n"
#: g10/trustdb.c:1227
msgid "Oops: key is now in trustdb???\n"
msgstr ""
#. update the ownertrust
#: g10/trustdb.c:1232
#, fuzzy, c-format
msgid "insert trust record failed: %s\n"
msgstr "ËÌÀÞ %08lX.%lu: ×ÓÔÁ×ËÁ ÄÏ×ÅÒÉÔÅÌØÎÏÊ ÚÁÐÉÓÉ ÎÅ ÕÄÁÌÁÓØ: %s\n"
#. error
#: g10/trustdb.c:1238
#, fuzzy, c-format
msgid "error finding dir record: %s\n"
msgstr "Fehler beim Erzeugen der \"Passphrase\": %s\n"
#: g10/trustdb.c:1305
#, c-format
msgid "user '%s' not in trustdb - inserting\n"
msgstr ""
#: g10/trustdb.c:1308
#, fuzzy, c-format
msgid "failed to put '%s' into trustdb: %s\n"
msgstr "ïÛÉÂËÁ ÉÎÉÃÉÁÌÉÚÁÃÉÉ ÂÁÚÙ ÄÁÎÎÙÈ ÄÏ×ÅÒÉÑ: %s\n"
#: g10/trustdb.c:1355
#, c-format
msgid "%s: keyblock read problem: %s\n"
msgstr ""
#: g10/trustdb.c:1369
#, fuzzy, c-format
msgid "%s: update failed: %s\n"
msgstr "ÏÂÎÏ×ÌÅÎÉÅ ÎÅ ÕÄÁÌÏÓØ: %s\n"
#: g10/trustdb.c:1372
#, c-format
msgid "%s: updated\n"
msgstr ""
#: g10/trustdb.c:1374
#, c-format
msgid "%s: okay\n"
msgstr ""
#: g10/trustdb.c:1389
#, c-format
msgid "lid %lu: dir record w/o key - skipped\n"
msgstr ""
#: g10/trustdb.c:1402
#, fuzzy, c-format
msgid "lid %lu: keyblock not found: %s\n"
msgstr "ËÌÀÞ %08lX: ÏÔËÒÙÔÙÊ ËÌÀÞ ÎÅ ÎÁÊÄÅÎ: %s\n"
#: g10/trustdb.c:1411 g10/trustdb.c:1480
#, fuzzy, c-format
msgid "lid %lu: update failed: %s\n"
msgstr "ÏÂÎÏ×ÌÅÎÉÅ ÎÅ ÕÄÁÌÏÓØ: %s\n"
#: g10/trustdb.c:1417 g10/trustdb.c:1486
#, c-format
msgid "lid %lu: updated\n"
msgstr ""
#: g10/trustdb.c:1421 g10/trustdb.c:1490
#, c-format
msgid "lid %lu: okay\n"
msgstr ""
#: g10/trustdb.c:1428 g10/trustdb.c:1496
#, c-format
msgid "%lu keys processed\n"
msgstr ""
#: g10/trustdb.c:1430
#, fuzzy, c-format
msgid "\t%lu keys skipped\n"
msgstr "%s: ÐÒÏÐÕÝÅÎ: %s\n"
#: g10/trustdb.c:1432 g10/trustdb.c:1498
#, fuzzy, c-format
msgid "\t%lu keys with errors\n"
msgstr "ïÛÉÂËÁ ÚÁÐÉÓÉ ÆÁÊÌÁ"
#: g10/trustdb.c:1434 g10/trustdb.c:1500
#, c-format
msgid "\t%lu keys updated\n"
msgstr ""
#: g10/trustdb.c:1464
#, fuzzy, c-format
msgid "lid ?: insert failed: %s\n"
msgstr "ÏÂÎÏ×ÌÅÎÉÅ ÓÅËÒÅÔÁ ÎÅ ÕÄÁÌÏÓØ: %s\n"
#: g10/trustdb.c:1469
#, fuzzy, c-format
msgid "lid %lu: insert failed: %s\n"
msgstr "ÏÂÎÏ×ÌÅÎÉÅ ÓÅËÒÅÔÁ ÎÅ ÕÄÁÌÏÓØ: %s\n"
#: g10/trustdb.c:1475
#, c-format
msgid "lid %lu: inserted\n"
msgstr ""
#: g10/trustdb.c:1502
#, c-format
msgid "\t%lu keys inserted\n"
msgstr ""
#: g10/trustdb.c:1505
#, fuzzy, c-format
msgid "enumerate keyblocks failed: %s\n"
msgstr "ÏÂÎÏ×ÌÅÎÉÅ ÓÅËÒÅÔÁ ÎÅ ÕÄÁÌÏÓØ: %s\n"
#: g10/trustdb.c:1550
#, fuzzy, c-format
msgid "check_trust: search dir record failed: %s\n"
msgstr "ËÌÀÞ %08lX.%lu: ×ÓÔÁ×ËÁ ÄÏ×ÅÒÉÔÅÌØÎÏÊ ÚÁÐÉÓÉ ÎÅ ÕÄÁÌÁÓØ: %s\n"
#: g10/trustdb.c:1557
#, fuzzy, c-format
msgid "key %08lX: insert trust record failed: %s\n"
msgstr "ËÌÀÞ %08lX.%lu: ×ÓÔÁ×ËÁ ÄÏ×ÅÒÉÔÅÌØÎÏÊ ÚÁÐÉÓÉ ÎÅ ÕÄÁÌÁÓØ: %s\n"
#: g10/trustdb.c:1561
#, c-format
msgid "key %08lX.%lu: inserted into trustdb\n"
msgstr "ËÌÀÞ %08lX.%lu: ×ÓÔÁ×ÌÅÎ × ÂÁÚÕ ÄÁÎÎÙÈ ÄÏ×ÅÒÉÑ\n"
#: g10/trustdb.c:1569
#, c-format
msgid "key %08lX.%lu: created in future (time warp or clock problem)\n"
msgstr ""
"ËÌÀÞ %08lX.%lu: ÓÇÅÎÅÒÉÒÏ×ÁÎ × ÂÕÄÕÝÅÍ (ÎÅÐÒÁ×ÉÌØÎÏ ÕÓÔÁÎÏ×ÌÅÎÙ ÞÁÓÙ)\n"
#: g10/trustdb.c:1576
#, c-format
msgid "key %08lX.%lu: expired at %s\n"
msgstr "ËÌÀÞ %08lX.%lu: ÓÒÏË ÄÅÊÓÔ×ÉÑ ÉÓÔÅË %s\n"
#: g10/trustdb.c:1584
#, c-format
msgid "key %08lX.%lu: trust check failed: %s\n"
msgstr "ËÌÀÞ %08lX.%lu: ÐÒÏ×ÅÒËÁ ÄÏ×ÅÒÉÑ ÎÅ ÕÄÁÌÁÓØ: %s\n"
#: g10/trustdb.c:1753 g10/trustdb.c:1782 g10/trustdb.c:2521
msgid "WARNING: can't yet handle long pref records\n"
msgstr ""
#: g10/trustdb.c:1804
#, fuzzy, c-format
msgid "get_dir_record: search_record failed: %s\n"
msgstr "ÏÂÎÏ×ÌÅÎÉÅ ÓÅËÒÅÔÁ ÎÅ ÕÄÁÌÏÓØ: %s\n"
#: g10/trustdb.c:1867
#, c-format
msgid "NOTE: sig rec %lu[%d] in hintlist of %lu but marked as checked\n"
msgstr ""
#: g10/trustdb.c:1871
#, c-format
msgid "NOTE: sig rec %lu[%d] in hintlist of %lu but not marked\n"
msgstr ""
#. we need the dir record
#: g10/trustdb.c:1878
#, c-format
msgid "sig rec %lu[%d] in hintlist of %lu does not point to a dir record\n"
msgstr ""
#: g10/trustdb.c:1884
#, c-format
msgid "lid %lu: no primary key\n"
msgstr ""
#: g10/trustdb.c:1917
#, fuzzy, c-format
msgid "lid %lu: user id not found in keyblock\n"
msgstr "%s: ÐÏÌØÚÏ×ÁÔÅÌØ ÎÅ ÎÁÊÄÅÎ\n"
#: g10/trustdb.c:1921
#, fuzzy, c-format
msgid "lid %lu: user id without signature\n"
msgstr "ËÌÀÞ %08lX: ÎÅÔ ÉÄÅÎÔÉÆÉËÁÔÏÒÁ ÐÏÌØÚÏ×ÁÔÅÌÑ ÄÌÑ ÐÏÄÐÉÓÉ\n"
#: g10/trustdb.c:1928
#, fuzzy, c-format
msgid "lid %lu: self-signature in hintlist\n"
msgstr "build_sigrecs: Selbst-Signatur fehlt\n"
#: g10/trustdb.c:1939 g10/trustdb.c:2658 g10/trustdb.c:2742
#, fuzzy
msgid "Valid certificate revocation"
msgstr "ðÌÏÈÏÊ ÓÅÒÔÉÆÉËÁÔ"
#: g10/trustdb.c:1940 g10/trustdb.c:2659 g10/trustdb.c:2743
#, fuzzy
msgid "Good certificate"
msgstr "ðÌÏÈÏÊ ÓÅÒÔÉÆÉËÁÔ"
#: g10/trustdb.c:1949
msgid "very strange: no public key\n"
msgstr ""
#: g10/trustdb.c:1997
#, c-format
msgid "hintlist %lu[%d] of %lu does not point to a dir record\n"
msgstr ""
#: g10/trustdb.c:2003
#, c-format
msgid "lid %lu does not have a key\n"
msgstr ""
#: g10/trustdb.c:2013
#, fuzzy, c-format
msgid "lid %lu: can't get keyblock: %s\n"
msgstr "ÎÅ×ÏÚÍÏÖÎÏ ÚÁÐÉÓÁÔØ ÂÌÏË ËÌÀÞÁ: %s\n"
#: g10/trustdb.c:2070 g10/trustdb.c:2984
#, fuzzy, c-format
msgid "tdbio_search_dir failed: %s\n"
msgstr "ÏÛÉÂËÁ ÄÅËÏÄÉÒÏ×ÁÎÉÑ: %s\n"
#: g10/trustdb.c:2223
#, fuzzy, c-format
msgid "key %08lX.%lu: Good subkey binding\n"
msgstr "ËÌÀÞ %08lX: ÎÅÔ ÉÄÅÎÔÉÆÉËÁÔÏÒÁ ÐÏÌØÚÏ×ÁÔÅÌÑ\n"
#: g10/trustdb.c:2229 g10/trustdb.c:2271
#, fuzzy, c-format
msgid "key %08lX.%lu: Invalid subkey binding: %s\n"
msgstr "ËÌÀÞ %08lX: ÎÅÔ ÄÏÐÕÓÔÉÍÙÈ ÉÄÅÎÔÉÆÉËÁÔÏÒÏ× ÐÏÌØÚÏ×ÁÔÅÌÅÊ\n"
#: g10/trustdb.c:2244
#, fuzzy, c-format
msgid "key %08lX.%lu: Valid key revocation\n"
msgstr "ËÌÀÞ %08lX.%lu: ÓÒÏË ÄÅÊÓÔ×ÉÑ ÉÓÔÅË %s\n"
#: g10/trustdb.c:2250
#, fuzzy, c-format
msgid "key %08lX.%lu: Invalid key revocation: %s\n"
msgstr "ËÌÀÞ %08lX: ÏÔËÒÙÔÙÊ ËÌÀÞ ÎÅ ÎÁÊÄÅÎ: %s\n"
#: g10/trustdb.c:2265
#, fuzzy, c-format
msgid "key %08lX.%lu: Valid subkey revocation\n"
msgstr "ËÌÀÞ %08lX: ÎÅÔ ÄÏÐÕÓÔÉÍÙÈ ÉÄÅÎÔÉÆÉËÁÔÏÒÏ× ÐÏÌØÚÏ×ÁÔÅÌÅÊ\n"
#: g10/trustdb.c:2365
#, fuzzy
msgid "Good self-signature"
msgstr "[ÓÁÍÏ-ÐÏÄÐÉÓØ]\n"
#: g10/trustdb.c:2376
#, fuzzy
msgid "Invalid self-signature"
msgstr "ËÌÀÞ %08lX: ÎÅÄÏÐÕÓÔÉÍÁÑ ÓÁÍÏ-ÐÏÄÐÉÓØ\n"
#: g10/trustdb.c:2386
msgid "Valid user ID revocation skipped due to a newer self signature\n"
msgstr ""
#: g10/trustdb.c:2393
#, fuzzy
msgid "Valid user ID revocation\n"
msgstr "îÅÄÏÐÕÓÔÉÍÙÊ ×ÙÂÏÒ.\n"
#: g10/trustdb.c:2400
#, fuzzy
msgid "Invalid user ID revocation"
msgstr "îÅÄÏÐÕÓÔÉÍÙÊ ×ÙÂÏÒ.\n"
#: g10/trustdb.c:2484
msgid "Too many preferences"
msgstr ""
#: g10/trustdb.c:2498
msgid "Too many preference items"
msgstr ""
#: g10/trustdb.c:2637
msgid "Duplicated certificate - deleted"
msgstr ""
#: g10/trustdb.c:2670
#, fuzzy
msgid "Hmmm, public key lost?"
msgstr "ðÌÏÈÏÊ ÏÔËÒÙÔÙÊ ËÌÀÞ"
#: g10/trustdb.c:2680 g10/trustdb.c:2763
#, fuzzy
msgid "Invalid certificate revocation"
msgstr "ðÌÏÈÏÊ ÓÅÒÔÉÆÉËÁÔ"
#: g10/trustdb.c:2681 g10/trustdb.c:2764
#, fuzzy
msgid "Invalid certificate"
msgstr "ðÌÏÈÏÊ ÓÅÒÔÉÆÉËÁÔ"
#: g10/trustdb.c:2696
#, c-format
msgid "uid %08lX.%lu/%02X%02X: has shadow dir %lu but is not yet marked.\n"
msgstr ""
#: g10/trustdb.c:2710
#, c-format
msgid "sig record %lu[%d] points to wrong record.\n"
msgstr ""
#. that should never happen
#: g10/trustdb.c:2954
#, fuzzy, c-format
msgid "insert_trust_record: keyblock not found: %s\n"
msgstr "ËÌÀÞ %08lX: ÓÅËÒÅÔÎÙÊ ËÌÀÞ ÎÅ ÎÁÊÄÅÎ: %s\n"
#: g10/trustdb.c:2972
msgid "did not use primary key for insert_trust_record()\n"
msgstr ""
#: g10/ringedit.c:293
#, fuzzy, c-format
msgid "%s: can't create keyring: %s\n"
msgstr "%s: ÎÅ×ÏÚÍÏÖÎÏ ÏÔËÒÙÔØ: %s\n"
#: g10/ringedit.c:299 g10/ringedit.c:1264
#, fuzzy, c-format
msgid "%s: keyring created\n"
msgstr "%s: ÎÅ×ÏÚÍÏÖÎÏ ÏÔËÒÙÔØ: %s\n"
#: g10/ringedit.c:1449
msgid "WARNING: 2 files with confidential information exists.\n"
msgstr ""
#: g10/ringedit.c:1450
#, fuzzy, c-format
msgid "%s is the unchanged one\n"
msgstr "éÓÐÏÌØÚÏ×ÁÎ ÎÅÐÒÁ×ÉÌØÎÙÊ ÓÅËÒÅÔÎÙÊ ËÌÀÞ"
#: g10/ringedit.c:1451
#, c-format
msgid "%s is the new one\n"
msgstr ""
#: g10/ringedit.c:1452
msgid "Please fix this possible security flaw\n"
msgstr ""
#: g10/skclist.c:94
#, fuzzy, c-format
msgid "skipped '%s': %s\n"
msgstr "%s: ÐÒÏÐÕÝÅÎ: %s\n"
#: g10/skclist.c:100
#, fuzzy, c-format
msgid ""
"skipped '%s': this is a PGP generated ElGamal key which is not secure for "
"signatures!\n"
msgstr "ÜÔÏÔ ElGamal ËÌÀÞ, ÓÏÚÄÁÎÎÙÊ PGP, ÎÅ ÎÁÄÅÖÅÎ ÄÌÑ ÓÏÚÄÁÎÉÑ ÐÏÄÐÉÓÅÊ!\n"
#. do not overwrite
#: g10/openfile.c:58
#, c-format
msgid "File '%s' exists. "
msgstr "æÁÊÌ '%s' ÓÕÝÅÓÔ×ÕÅÔ. "
#: g10/openfile.c:60
msgid "Overwrite (y/N)? "
msgstr "ðÅÒÅÐÉÓÁÔØ (y/N)? "
#: g10/openfile.c:85
#, fuzzy
msgid "writing to stdout\n"
msgstr "ÚÁÐÉÓÙ×ÁÅÔÓÑ × '%s'\n"
#: g10/openfile.c:134
#, fuzzy, c-format
msgid "assuming signed data in '%s'\n"
msgstr "ÎÅ×ÏÚÍÏÖÎÏ ÏÔËÒÙÔØ ÐÏÄÐÉÓÁÎÎÙÅ ÄÁÎÎÙÅ '%s' .\n"
#: g10/openfile.c:181
#, c-format
msgid "%s: new options file created\n"
msgstr ""
#: g10/encr-data.c:59
#, fuzzy, c-format
msgid "%s encrypted data\n"
msgstr "ÚÁÛÉÆÒÏ×ÁÔØ ÄÁÎÎÙÅ"
#: g10/encr-data.c:61
#, c-format
msgid "encrypted with unknown algorithm %d\n"
msgstr ""
#: g10/encr-data.c:74
#, fuzzy
msgid ""
"WARNING: Message was encrypted with a weak key in the symmetric cipher.\n"
msgstr ""
"ðÒÅÄÕÐÒÅÖÄÅÎÉÅ: ÓÏÏÂÝÅÎÉÅ ÂÙÌÏ ÚÁÛÉÆÒÏ×ÁÎÏ, ÉÓÐÏÌØÚÕÑ ÓÌÁÂÙÊ ËÌÀÞ, × "
"ÓÉÍÍÅÔÒÉÞÎÏÍ ÁÌÇÏÒÉÔÍÅ ÛÉÆÒÏ×ÁÎÉÑ.\n"
#: g10/seskey.c:52
msgid "weak key created - retrying\n"
msgstr "ÐÏÌÕÞÉÌÓÑ ÓÌÁÂÙÊ ËÌÀÞ, ÐÒÏÂÕÅÍ ÅÝÅ ÒÁÚ\n"
#: g10/seskey.c:57
#, c-format
msgid "cannot avoid weak key for symmetric cipher; tried %d times!\n"
msgstr ""
"ÎÅ ÐÏÌÕÞÁÅÔÓÑ ÉÚÂÅÖÁÔØ ÓÌÁÂÏÇÏ ËÌÀÞÁ × ÓÉÍÍÅÔÒÉÞÎÏÍ ÁÌÇÏÒÉÔÍÅ; ÐÒÏÂÏ×ÁÌÉ %d "
"ÒÁÚ!\n"
#. begin of list
#: g10/helptext.c:45
msgid "edit_ownertrust.value"
msgstr ""
#: g10/helptext.c:51
msgid "revoked_key.override"
msgstr ""
#: g10/helptext.c:55
msgid "untrusted_key.override"
msgstr ""
#: g10/helptext.c:59
msgid "pklist.user_id.enter"
msgstr ""
#: g10/helptext.c:63
msgid "keygen.algo"
msgstr ""
#: g10/helptext.c:79
msgid "keygen.algo.elg_se"
msgstr ""
#: g10/helptext.c:86
msgid "keygen.size"
msgstr ""
#: g10/helptext.c:90
msgid "keygen.size.huge.okay"
msgstr ""
#: g10/helptext.c:95
msgid "keygen.size.large.okay"
msgstr ""
#: g10/helptext.c:100
msgid "keygen.valid"
msgstr ""
#: g10/helptext.c:104
msgid "keygen.valid.okay"
msgstr ""
#: g10/helptext.c:109
msgid "keygen.name"
msgstr ""
#: g10/helptext.c:114
msgid "keygen.email"
msgstr ""
#: g10/helptext.c:118
msgid "keygen.comment"
msgstr ""
#: g10/helptext.c:123
msgid "keygen.userid.cmd"
msgstr ""
#: g10/helptext.c:132
msgid "keygen.sub.okay"
msgstr ""
#: g10/helptext.c:136
msgid "sign_uid.okay"
msgstr ""
#: g10/helptext.c:141
msgid "change_passwd.empty.okay"
msgstr ""
#: g10/helptext.c:146
msgid "keyedit.cmd"
msgstr ""
#: g10/helptext.c:150
msgid "keyedit.save.okay"
msgstr ""
#: g10/helptext.c:155
msgid "keyedit.cancel.okay"
msgstr ""
#: g10/helptext.c:159
msgid "keyedit.sign_all.okay"
msgstr ""
#: g10/helptext.c:163
msgid "keyedit.remove.uid.okay"
msgstr ""
#: g10/helptext.c:168
msgid "keyedit.remove.subkey.okay"
msgstr ""
# ################################
# ####### Help msgids ############
# ################################
#: g10/helptext.c:172
msgid "passphrase.enter"
msgstr ""
"Bitte geben Sie die \"Passhrase\" ein; dies ist ein geheimer Satz der aus\n"
"beliebigen Zeichen bestehen kann. Was Sie eingegeben wird nicht angezeigt.\n"
"Zur ihrer eigenen Sicherbeit benutzen Sie biite einen Satz, den sie sich\n"
"gut merken könne, der aber nicht leicht zu raten ist; Zitate und andere\n"
"bekannte Texte sind eine SCHLECHTE Wahl, da diese mit Sicherheit online\n"
"verfügbar sind und durch entsprechende Programme zum Raten der "
"\"Passphrase\"\n"
"benutzt werden. Sätze mit persönlicher Bedeutung, die auch noch durch\n"
"falsche Groß-/Kleinschreibung und eingestreute Sonderzeichen verändert "
"werden,\n"
"sind i.d.R. eine gute Wahl"
#: g10/helptext.c:179
msgid "passphrase.repeat"
msgstr ""
"Um sicher zu gehen, daß Sie sich bei der Eingabe der \"Passphrase\" nicht\n"
"vertippt haben, geben Sie diese bitte nochmal ein. Nur wenn beide Eingaben\n"
"übereinstimmen, wird die \"Passphrase\" akzeptiert."
#: g10/helptext.c:183
#, fuzzy
msgid "detached_signature.filename"
msgstr "ÉÍÑ ÆÁÊÌÁ ÄÌÑ ÏÔÄÅÌØÎÏÊ ÐÏÄÐÉÓÉ"
#: g10/helptext.c:187
msgid "openfile.overwrite.okay"
msgstr "÷Ù ÖÅÌÁÅÔÅ ÐÅÒÅÚÁÐÉÓÁÔØ ÆÁÊÌ (×ÏÚÍÏÖÎÁ ÐÏÔÅÒÑ ÄÁÎÎÙÈ)"
#: g10/helptext.c:201
msgid "No help available"
msgstr "ðÏÍÏÝØ ÏÔÓÕÔÓÔ×ÕÅÔ."
#: g10/helptext.c:213
#, c-format
msgid "No help available for '%s'"
msgstr "ðÏÍÏÝØ ÄÌÑ '%s' ÏÔÓÕÔÓÔ×ÕÅÔ."
#~ msgid "You will see a list of signators etc. here\n"
#~ msgstr "úÄÅÓØ ×Ù Õ×ÉÄÉÔÅ ÓÐÉÓÏË ÐÏÄÐÉÓÁ×ÛÉÈ É Ô.Ä.\n"
#~ msgid "key %08lX: already in ultikey_table\n"
#~ msgstr "ËÌÀÞ %08lX: ÕÖÅ × ultikey_table\n"
#, fuzzy
#~ msgid "key %08lX.%lu, uid %02X%02X: no public key for signature %08lX\n"
#~ msgstr ""
#~ "ËÌÀÞ %08lX.%lu, uid %02X%02X: ÎÅÔ ÏÔËÒÙÔÏÇÏ ËÌÀÞÁ ÄÌÑ ÐÏÄÐÉÓÉ %08lX\n"
#, fuzzy
#~ msgid "key %08lX.%lu, uid %02X%02X: invalid %ssignature: %s\n"
#~ msgstr "ËÌÀÞ %08lX: ÎÅÄÏÐÕÓÔÉÍÁÑ ÓÁÍÏ-ÐÏÄÐÉÓØ\n"
#~ msgid "can't write keyring\n"
#~ msgstr "kann ËÌÀÞring nicht schreiben\n"
#~ msgid "make a signature on a key in the keyring"
#~ msgstr "ËÌÀÞ signieren"
#~ msgid "edit a key signature"
#~ msgstr "Bearbeiten der Signaturen eines ËÌÀÞs"
#~ msgid "do not make any changes"
#~ msgstr "Keine wirklichen Änderungen durchführen"
#~ msgid ""
#~ "It's up to you to assign a value here; this value will never be exported\n"
#~ "to any 3rd party. We need it to implement the web-of-trust; it has nothing\n"
#~ "to do with the (implicitly created) web-of-certificates.\n"
#~ msgstr ""
#~ "Sie müssen selbt entscheiden, welchen Wert Sie hier eintragen; dieser Wert\n"
#~ "wird niemals an eine dritte Seite weitergegeben. Wir brauchen diesen Wert,\n"
#~ "um das \"Netz des Vertrauens\" aufzubauen. Dieses hat nichts mit dem "
#~ "(implizit\n"
#~ "erzeugten) \"Netz der Zertifikate\" zu tun.\n"
#~ msgid "public and secret subkey created.\n"
#~ msgstr "Öffentlicher und privater ËÌÀÞ erzeugt.\n"
#~ msgid "No public key for %d signatures\n"
#~ msgstr "Kein öffentlicher ËÌÀÞ für %d Signaturen\n"
#~ msgid "[User name not available] "
#~ msgstr "[Benuzername nicht verfügbar] "
#~ msgid "This is a BAD signature!\n"
#~ msgstr "Dies ist eine FALSCHE Signatur!\n"
#~ msgid "The signature could not be checked!\n"
#~ msgstr "Die Signatur konnte nicht geprüft werden!\n"
#~ msgid "Checking signatures of this public key certificate:\n"
#~ msgstr "Die Signaturen dieses Zertifikats werden überprüft:\n"
#~ msgid "Do you want to remove some of the invalid signatures? "
#~ msgstr "Möchten Sie einige der ungültigen Signaturen entfernen? "
#~ msgid "there is a secret key for this public key!\n"
#~ msgstr "Es gibt einen privaten ËÌÀÞ zu diesem öffentlichen ËÌÀÞ!\n"
#~ msgid "use option \"--delete-secret-key\" to delete it first.\n"
#~ msgstr ""
#~ "Benutzen Sie das Kommando \"--delete-secret-key\", um ihn vorab zu "
#~ "entfernen.\n"
#~ msgid "can't do that in batchmode without \"--yes\"\n"
#~ msgstr "Dies kann im Batchmodus ohne \"--yes\" nicht durchgeführt werden.\n"
#~ msgid "Delete this key from the keyring? "
#~ msgstr "Diesen ËÌÀÞ aus dem ËÌÀÞring löschen? "
#~ msgid "This is a secret key! - really delete? "
#~ msgstr "Dies ist ein privater ËÌÀÞ! - Wirklich löschen? "
diff --git a/scripts/ChangeLog b/scripts/ChangeLog
index 61034c23a..eb1fe5ab2 100644
--- a/scripts/ChangeLog
+++ b/scripts/ChangeLog
@@ -1,19 +1,24 @@
+Thu Dec 17 18:31:15 CET 1998 Werner Koch <wk@isil.d.shuttle.de>
+
+ * gnupg.spec: New version by Reuben Sumner and did some more
+ changes.
+
Fri Nov 27 12:39:29 CET 1998 Werner Koch <wk@isil.d.shuttle.de>
* commit: New
Fri Nov 20 12:01:57 1998 Werner Koch (wk@isil.d.shuttle.de)
* mkdiff: signs the patch file
Sat Oct 17 16:10:16 1998 Werner Koch (wk@isil.d.shuttle.de)
* autogen.sh: New.
Wed Oct 14 09:55:25 1998 Werner Koch (wk@isil.d.shuttle.de)
* config.guess (FreeBSD): Changes from Jun Kuriyama to support ELF
* config.sub: (freebsd): Add to maybe_os
diff --git a/scripts/gnupg.spec b/scripts/gnupg.spec
index f654ab1a0..e2961e50f 100644
--- a/scripts/gnupg.spec
+++ b/scripts/gnupg.spec
@@ -1,60 +1,58 @@
#
# gnupg -- gnu privacy guard
# This is a template. The dist target uses it to create the real file.
#
+%define version @pkg_version@
Summary: GPL public key crypto
Name: gnupg
-Version: @pkg_version@
-Release: 3
+Version: %{version}
+Release: 1
Copyright: GPL
Group: Applications/Cryptography
-Source: ftp://ftp.guug.de/pub/gcrypt/
-URL: http://www.d.shuttle.de/isil/crypt/gnupg.html
-Vendor: TechnoCage
-Packager: Caskey L. Dickson <caskey-at-technocage.com>
+Source: ftp://ftp.gnupg.org/pub/gcrypt/gnupg-%{version}.tar.gz
+URL: http://www.gnupg.org
Provides: gpg openpgp
+BuildRoot: /tmp/gnupg
%description
-GNUPG is a complete and free replacement for PGP. Because it does not use
-IDEA or RSA it can be used without any restrictions. GNUPG is nearly in
-compliance with the OpenPGP draft.
+GnuPG is a complete and free replacement for PGP. Because it does not use
+IDEA or RSA it can be used without any restrictions. GnuPG is in
+compliance with the OpenPGP specification (RFC2440).
%prep
-rm -rf $RPM_BUILD_DIR/gnupg-@pkg_version@
-tar -xvzf $RPM_SOURCE_DIR/gnupg-@pkg_version@.tar.gz
+%setup
+
+rm -rf $RPM_BUILD_ROOT
%build
-cd gnupg-@pkg_version@
-chown -R root.root *
-./configure --prefix=/usr
+CFLAGS="$RPM_OPT_FLAGS" ./configure --prefix=/usr
make
%install
-cd gnupg-@pkg_version@
-make install
+make prefix="${RPM_BUILD_ROOT}/usr" install
-%files
-%doc gnupg-@pkg_version@/doc/DETAILS
-%doc gnupg-@pkg_version@/INSTALL
-%doc gnupg-@pkg_version@/doc/rfcs
-%doc gnupg-@pkg_version@/AUTHORS
-%doc gnupg-@pkg_version@/ABOUT-NLS
-%doc gnupg-@pkg_version@/COPYING
-%doc gnupg-@pkg_version@/ChangeLog
-%doc gnupg-@pkg_version@/NEWS
-%doc gnupg-@pkg_version@/README
-%doc gnupg-@pkg_version@/THANKS
-%doc gnupg-@pkg_version@/TODO
-/usr/man/man1/gpg.1
-/usr/bin/gpg
-/usr/bin/gpgm
-/usr/share/locale/en/LC_MESSAGES/gnupg.mo
-/usr/share/locale/de/LC_MESSAGES/gnupg.mo
-/usr/share/locale/it/LC_MESSAGES/gnupg.mo
-/usr/share/locale/fr/LC_MESSAGES/gnupg.mo
-/usr/lib/gnupg/tiger
-/usr/lib/gnupg/twofish
+%clean
+rm -rf $RPM_BUILD_ROOT
+%files
+%attr(-,root,root) %doc doc/DETAILS
+%attr(-,root,root) %doc INSTALL
+%attr(-,root,root) %doc AUTHORS
+%attr(-,root,root) %doc ABOUT-NLS
+%attr(-,root,root) %doc COPYING
+%attr(-,root,root) %doc ChangeLog
+%attr(-,root,root) %doc NEWS
+%attr(-,root,root) %doc README
+%attr(-,root,root) %doc THANKS
+%attr(-,root,root) %doc TODO
+%attr(-,root,root) /usr/man/man1/gpg.1
%attr (4755,root,root) /usr/bin/gpg
-%attr (4755,root,root) /usr/bin/gpgm
+%attr (755,root,root) /usr/bin/gpgm
+%attr(-,root,root) /usr/share/locale/en/LC_MESSAGES/gnupg.mo
+%attr(-,root,root) /usr/share/locale/de/LC_MESSAGES/gnupg.mo
+%attr(-,root,root) /usr/share/locale/it/LC_MESSAGES/gnupg.mo
+%attr(-,root,root) /usr/share/locale/fr/LC_MESSAGES/gnupg.mo
+%attr(-,root,root) /usr/lib/gnupg/tiger
+%attr(-,root,root) /usr/lib/gnupg/twofish
+%attr(-,root,root) /usr/share/gnupg/options.skel

File Metadata

Mime Type
text/x-diff
Expires
Sat, Jan 17, 2:25 AM (10 h, 39 m)
Storage Engine
local-disk
Storage Format
Raw Data
Storage Handle
1d/3f/eb88a32290d4a43881eeb89663bd

Event Timeline