doc: Minor change to the included yat2m.
[gnupg.git] / doc / gpg-card.texi
1 @c card-tool.texi - man page for gpg-card-tool
2 @c Copyright (C) 2019 g10 Code GmbH
3 @c This is part of the GnuPG manual.
4 @c For copying conditions, see the file GnuPG.texi.
5
6 @include defs.inc
7
8 @node Smart Card Tool
9 @chapter Smart Card Tool
10
11 GnuPG comes with a tool to administrate smart cards and USB tokens.
12 This tool is an enhanced version of the @option{--edit-key} command
13 available with @command{gpg}.
14
15 @menu
16 * gpg-card::             Administrate smart cards.
17 @end menu
18
19 @c
20 @c  GPG-CARD-TOOL
21 @c
22 @manpage gpg-card.1
23 @node gpg-card
24 @section Administrate smart cards.
25 @ifset manverb
26 .B gpg-card
27 \- Administrate Smart Cards
28 @end ifset
29
30 @mansect synopsis
31 @ifset manverb
32 .B gpg-card
33 .RI [ options ]
34 .br
35 .B gpg-card
36 .RI [ options ]
37 .I command
38 .RI {
39 .B --
40 .I command
41 .RI }
42 @end ifset
43
44 @mansect description
45 The @command{gpg-card} is used to administrate smart cards and USB
46 tokens.  It provides a superset of features from @command{gpg
47 --card-edit} an can be considered a frontend to @command{scdaemon}
48 which is a daemon started by @command{gpg-agent} to handle smart
49 cards.
50
51 If @command{gpg-card} is invoked without commands an interactive
52 mode is used.
53
54 If @command{gpg-card} is invoked with one or more commands the
55 same commands as available in the interactive mode are run from the
56 command line.  These commands need to be delimited with a double-dash.
57 If a double-dash or a shell specific character is required as part of
58 a command the entire command needs to be put in quotes.  If one of
59 those commands returns an error the remaining commands are mot anymore
60 run unless the command was prefixed with a single dash.
61
62 A list of commands is available by using the command @code{help} and a
63 detailed description of each command is printed by using @code{help
64 COMMAND}.
65
66 See the NOTES sections for instructions pertaining to specific cards
67 or card applications.
68
69 @mansect options
70 @noindent
71 @command{gpg-card} understands these options:
72
73 @table @gnupgtabopt
74
75 @item --with-colons
76 @opindex with-colons
77 This option has currently no effect.
78
79 @item --status-fd @var{n}
80 @opindex status-fd
81 Write special status strings to the file descriptor @var{n}.  This
82 program returns only the status messages SUCCESS or FAILURE which are
83 helpful when the caller uses a double fork approach and can't easily
84 get the return code of the process.
85
86 @item --verbose
87 @opindex verbose
88 Enable extra informational output.
89
90 @item --quiet
91 @opindex quiet
92 Disable almost all informational output.
93
94 @item --version
95 @opindex version
96 Print version of the program and exit.
97
98 @item --help
99 @opindex help
100 Display a brief help page and exit.
101
102 @item --no-autostart
103 @opindex no-autostart
104 Do not start the gpg-agent if it has not yet been started and its
105 service is required.  This option is mostly useful on machines where
106 the connection to gpg-agent has been redirected to another machines.
107
108 @item --agent-program @var{file}
109 @opindex agent-program
110 Specify the agent program to be started if none is running.  The
111 default value is determined by running @command{gpgconf} with the
112 option @option{--list-dirs}.
113
114 @item --gpg-program @var{file}
115 @opindex gpg-program
116 Specify a non-default gpg binary to be used by certain commands.
117
118 @item --gpgsm-program @var{file}
119 @opindex gpgsm-program
120 Specify a non-default gpgsm binary to be used by certain commands.
121
122 @end table
123
124 @mansect notes (OpenPGP)
125 The support for OpenPGP cards in @command{gpg-card} is not yet
126 complete.  For missing features, please continue to use @code{gpg
127 --card-edit}.
128
129 @mansect notes (PIV)
130 @noindent
131 GnuPG has support for PIV cards (``Personal Identity Verification''
132 as specified by NIST Special Publication 800-73-4).  This section
133 describes how to initialize (personalize) a fresh Yubikey token
134 featuring the PIV application (requires Yubikey-5).  We assume that
135 the credentials have not yet been changed and thus are:
136 @table @asis
137 @item Authentication key
138 This is a 24 byte key described by the hex string @*
139 @code{010203040506070801020304050607080102030405060708}.
140 @item PIV Application PIN
141 This is the string @code{123456}.
142 @item PIN Unblocking Key
143 This is the string @code{12345678}.
144 @end table
145 See the example section on how to change these defaults.  For
146 production use it is important to use secure values for them.  Note that
147 the Authentication Key is not queried via the usual Pinentry dialog
148 but needs to be entered manually or read from a file.  The use of a
149 dedicated machine to personalize tokens is strongly suggested.
150
151 To see what is on the card, the command @code{list} can be given.  We
152 will use the interactive mode in the following (the string
153 @emph{gpg/card>} is the prompt).  An example output for a fresh card
154 is:
155
156 @example
157 gpg/card> list
158 Reader ...........: 1050:0407:X:0
159 Card type ........: yubikey
160 Card firmware ....: 5.1.2
161 Serial number ....: D2760001240102010006090746250000
162 Application type .: OpenPGP
163 Version ..........: 2.1
164 [...]
165 @end example
166
167 It can be seen by the ``Application type'' line that GnuPG selected
168 the OpenPGP application of the Yubikey.  This is because GnuPG assigns
169 the highest priority to the OpenPGP application.  To use the PIV
170 application of the Yubikey several methods can be used:
171
172 With a Yubikey 5 or later the OpenPGP application on the Yubikey can
173 be disabled:
174
175 @example
176 gpg/card> yubikey disable all opgp
177 gpg/card> yubikey list
178 Application  USB    NFC
179 -----------------------
180 OTP          yes    yes
181 U2F          yes    yes
182 OPGP         no     no
183 PIV          yes    no
184 OATH         yes    yes
185 FIDO2        yes    yes
186 gpg/card> reset
187 @end example
188
189 The @code{reset} is required so that the GnuPG system rereads the
190 card.  Note that disabled applications keep all their data and can at
191 any time be re-enabled (use @kbd{help yubikey}).
192
193 Another option, which works for all Yubikey versions, is to disable
194 the support for OpenPGP cards in scdaemon.  This is done by adding the
195 line
196
197 @smallexample
198 disable-application openpgp
199 @end smallexample
200
201 to @file{~/.gnupg/scdaemon.conf} and by restarting scdaemon, either by
202 killing the process or by using @kbd{gpgconf --kill scdaemon}.  Finally
203 the default order in which card applications are tried by scdaemon can
204 be changed.   For example to prefer PIV over OpenPGP it is sufficient
205 to add
206
207 @smallexample
208 application-priority piv
209 @end smallexample
210
211 to @file{~/.gnupg/scdaemon.conf} and to restart @command{scdaemon}.
212 This has an effect only on tokens which support both, PIV and OpenPGP,
213 but does not hamper the use of OpenPGP only tokens.
214
215 With one of these methods employed the @code{list} command of
216 @command{gpg-card} shows this:
217
218 @example
219 gpg/card> list
220 Reader ...........: 1050:0407:X:0
221 Card type ........: yubikey
222 Card firmware ....: 5.1.2
223 Serial number ....: FF020001008A77C1
224 Application type .: PIV
225 Version ..........: 1.0
226 Displayed s/n ....: yk-9074625
227 PIN usage policy .: app-pin
228 PIN retry counter : - 3 -
229 PIV authentication: [none]
230       keyref .....: PIV.9A
231 Card authenticat. : [none]
232       keyref .....: PIV.9E
233 Digital signature : [none]
234       keyref .....: PIV.9C
235 Key management ...: [none]
236       keyref .....: PIV.9D
237 @end example
238
239 In case several tokens are plugged into the computer, gpg-card will
240 show only one.  To show another token the number of the token (0, 1,
241 2, ...) can be given as an argument to the @code{list} command.  The
242 command @kbd{list --cards} prints a list of all inserted tokens.
243
244 Note that the ``Displayed s/n'' is printed on the token and also
245 shown in Pinentry prompts asking for the PIN.  The four standard key
246 slots are always shown, if other key slots are initialized they are
247 shown as well.  The @emph{PIV authentication} key (internal reference
248 @emph{PIV.9A}) is used to authenticate the card and the card holder.
249 The use of the associated private key is protected by the Application
250 PIN which needs to be provided once and the key can the be used until
251 the card is reset or removed from the reader or USB port.  GnuPG uses
252 this key with its @emph{Secure Shell} support.  The @emph{Card
253 authentication} key (@emph{PIV.9E}) is also known as the CAK and used
254 to support physical access applications.  The private key is not
255 protected by a PIN and can thus immediately be used.  The @emph{Digital
256 signature} key (@emph{PIV.9C}) is used to digitally sign documents.
257 The use of the associated private key is protected by the Application
258 PIN which needs to be provided for each signing operation.  The
259 @emph{Key management} key (@emph{PIV.9D}) is used for encryption.  The
260 use of the associated private key is protected by the Application PIN
261 which needs to be provided only once so that decryption operations can
262 then be done until the card is reset or removed from the reader or USB
263 port.
264
265 We now generate three of the four keys.  Note that GnuPG does
266 currently not use the the @emph{Card authentication} key; however,
267 that key is mandatory by the PIV standard and thus we create it too.
268 Key generation requires that we authenticate to the card.  This can be
269 done either on the command line (which would reveal the key):
270
271 @example
272 gpg/card> auth 010203040506070801020304050607080102030405060708
273 @end example
274
275 or by reading the key from a file.  That file needs to consist of one
276 LF terminated line with the hex encoded key (as above):
277
278 @example
279 gpg/card> auth < myauth.key
280 @end example
281
282 As usual @samp{help auth} gives help for this command.  An error
283 message is printed if a non-matching key is used.  The authentication
284 is valid until a reset of the card or until the card is removed from
285 the reader or the USB port.  Note that that in non-interactive mode
286 the @samp{<} needs to be quoted so that the shell does not interpret
287 it as a its own redirection symbol.
288
289 @noindent
290 Here are the actual commands to generate the keys:
291
292 @example
293 gpg/card> generate --algo=nistp384 PIV.9A
294 PIV card no. yk-9074625 detected
295 gpg/card> generate --algo=nistp256 PIV.9E
296 PIV card no. yk-9074625 detected
297 gpg/card> generate --algo=rsa2048 PIV.9C
298 PIV card no. yk-9074625 detected
299 @end example
300
301 If a key has already been created for one of the slots an error will
302 be printed; to create a new key anyway the option @samp{--force} can be
303 used.  Note that only the private and public keys have been created
304 but no certificates are stored in the key slots.  In fact, GnuPG uses
305 its own non-standard method to store just the public key in place of
306 the the certificate.  Other application will not be able to make use
307 these keys until @command{gpgsm} or another tool has been used to
308 create and store the respective certificates.   Let us see what the
309 list command now shows:
310
311 @example
312 gpg/card> list
313 Reader ...........: 1050:0407:X:0
314 Card type ........: yubikey
315 Card firmware ....: 5.1.2
316 Serial number ....: FF020001008A77C1
317 Application type .: PIV
318 Version ..........: 1.0
319 Displayed s/n ....: yk-9074625
320 PIN usage policy .: app-pin
321 PIN retry counter : - 3 -
322 PIV authentication: 213D1825FDE0F8240CB4E4229F01AF90AC658C2E
323       keyref .....: PIV.9A  (auth)
324       algorithm ..: nistp384
325 Card authenticat. : 7A53E6CFFE7220A0E646B4632EE29E5A7104499C
326       keyref .....: PIV.9E  (auth)
327       algorithm ..: nistp256
328 Digital signature : 32A6C6FAFCB8421878608AAB452D5470DD3223ED
329       keyref .....: PIV.9C  (sign,cert)
330       algorithm ..: rsa2048
331 Key management ...: [none]
332       keyref .....: PIV.9D
333 @end example
334
335 The primary information for each key is the @emph{keygrip}, a 40 byte
336 hex-string identifying the key.  This keygrip is a unique identifier
337 for the specific parameters of a key.  It is used by
338 @command{gpg-agent} and other parts of GnuPG to associate a private
339 key to its protocol specific certificate format (X.509, OpenPGP, or
340 SecureShell).  Below the keygrip the key reference along with the key
341 usage capabilities are show.  Finally the algorithm is printed in the
342 format used by @command {gpg}.  At that point no other information is
343 shown because for these new keys gpg won't be able to find matching
344 certificates.
345
346 Although we could have created the @emph{Key management} key also with
347 the generate command, we will create that key off-card so that a
348 backup exists.  To accomplish this a key needs to be created with
349 either @command{gpg} or @command{gpgsm} or imported in one of these
350 tools.  In our example we create a self-signed X.509 certificate (exit
351 the gpg-card tool, first):
352
353 @example
354 $ gpgsm --gen-key -o encr.crt
355    (1) RSA
356    (2) Existing key
357    (3) Existing key from card
358 Your selection? 1
359 What keysize do you want? (3072) 2048
360 Requested keysize is 2048 bits
361 Possible actions for a RSA key:
362    (1) sign, encrypt
363    (2) sign
364    (3) encrypt
365 Your selection? 3
366 Enter the X.509 subject name: CN=Encryption key for yk-9074625,O=example,C=DE
367 Enter email addresses (end with an empty line):
368 > otto@@example.net
369 >
370 Enter DNS names (optional; end with an empty line):
371 >
372 Enter URIs (optional; end with an empty line):
373 >
374 Create self-signed certificate? (y/N) y
375 These parameters are used:
376     Key-Type: RSA
377     Key-Length: 2048
378     Key-Usage: encrypt
379     Serial: random
380     Name-DN: CN=Encryption key for yk-9074625,O=example,C=DE
381     Name-Email: otto@@example.net
382
383 Proceed with creation? (y/N)
384 Now creating self-signed certificate.  This may take a while ...
385 gpgsm: about to sign the certificate for key: &34798AAFE0A7565088101CC4AE31C5C8C74461CB
386 gpgsm: certificate created
387 Ready.
388 $ gpgsm --import encr.crt
389 gpgsm: certificate imported
390 gpgsm: total number processed: 1
391 gpgsm:               imported: 1
392 @end example
393
394 Note the last step which imported the created certificate.  If you
395 you instead created a certificate signing request (CSR) instead of a
396 self-signed certificate and sent this off to a CA you would do the
397 same import step with the certificate received from the CA.  Take note
398 of the keygrip (prefixed with an ampersand) as shown during the
399 certificate creation or listed it again using @samp{gpgsm
400 --with-keygrip -k otto@@example.net}.  Now to move the key and
401 certificate to the card start @command{gpg-card} again and enter:
402
403 @example
404 gpg/card> writekey PIV.9D 34798AAFE0A7565088101CC4AE31C5C8C74461CB
405 gpg/card> writecert PIV.9D < encr.crt
406 @end example
407
408 If you entered a passphrase to protect the private key, you will be
409 asked for it via the Pinentry prompt.  On success the key and the
410 certificate has been written to the card and a @code{list} command
411 shows:
412
413 @example
414 [...]
415 Key management ...: 34798AAFE0A7565088101CC4AE31C5C8C74461CB
416       keyref .....: PIV.9D  (encr)
417       algorithm ..: rsa2048
418       used for ...: X.509
419         user id ..: CN=Encryption key for yk-9074625,O=example,C=DE
420         user id ..: <otto@@example.net>
421 @end example
422
423 In case the same key (identified by the keygrip) has been used for
424 several certificates you will see several ``used for'' parts.  With
425 this the encryption key is now fully functional and can be used to
426 decrypt messages encrypted to this certificate.  @sc{Take care:} the
427 original key is still stored on-disk and should be moved to a backup
428 medium.  This can simply be done by copying the file
429 @file{34798AAFE0A7565088101CC4AE31C5C8C74461CB.key} from the directory
430 @file{~/.gnupg/private-keys-v1.d/} to the backup medium and deleting
431 the file at its original place.
432
433 The final example is to create a self-signed certificate for digital
434 signatures.  Leave @command{gpg-card} using @code{quit} or by pressing
435 Control-D and use gpgsm:
436
437 @example
438 $ gpgsm --learn
439 $ gpgsm --gen-key -o sign.crt
440 Please select what kind of key you want:
441    (1) RSA
442    (2) Existing key
443    (3) Existing key from card
444 Your selection? 3
445 Serial number of the card: FF020001008A77C1
446 Available keys:
447    (1) 213D1825FDE0F8240CB4E4229F01AF90AC658C2E PIV.9A nistp384
448    (2) 7A53E6CFFE7220A0E646B4632EE29E5A7104499C PIV.9E nistp256
449    (3) 32A6C6FAFCB8421878608AAB452D5470DD3223ED PIV.9C rsa2048
450    (4) 34798AAFE0A7565088101CC4AE31C5C8C74461CB PIV.9D rsa2048
451 Your selection? 3
452 Possible actions for a RSA key:
453    (1) sign, encrypt
454    (2) sign
455    (3) encrypt
456 Your selection? 2
457 Enter the X.509 subject name: CN=Signing key for yk-9074625,O=example,C=DE
458 Enter email addresses (end with an empty line):
459 > otto@@example.net
460 >
461 Enter DNS names (optional; end with an empty line):
462 >
463 Enter URIs (optional; end with an empty line):
464 >
465 Create self-signed certificate? (y/N)
466 These parameters are used:
467     Key-Type: card:PIV.9C
468     Key-Length: 1024
469     Key-Usage: sign
470     Serial: random
471     Name-DN: CN=Signing key for yk-9074625,O=example,C=DE
472     Name-Email: otto@@example.net
473
474 Proceed with creation? (y/N) y
475 Now creating self-signed certificate.  This may take a while ...
476 gpgsm: about to sign the certificate for key: &32A6C6FAFCB8421878608AAB452D5470DD3223ED
477 gpgsm: certificate created
478 Ready.
479 $ gpgsm --import sign.crt
480 gpgsm: certificate imported
481 gpgsm: total number processed: 1
482 gpgsm:               imported: 1
483 @end example
484
485 The use of @samp{gpgsm --learn} is currently necessary so that
486 gpg-agent knows what keys are available on the card.  The need for
487 this command will eventually be removed.  The remaining commands are
488 similar to the creation of an on-disk key.  However, here we select
489 the @samp{Digital signature} key.  During the creation process you
490 will be asked for the Application PIN of the card.  The final step is
491 to write the certificate to the card using @command{gpg-card}:
492
493 @example
494 gpg/card> writecert PIV.9C < sign.crt
495 @end example
496
497 By running list again we will see the fully initialized card:
498
499 @example
500 Reader ...........: 1050:0407:X:0
501 Card type ........: yubikey
502 Card firmware ....: 5.1.2
503 Serial number ....: FF020001008A77C1
504 Application type .: PIV
505 Version ..........: 1.0
506 Displayed s/n ....: yk-9074625
507 PIN usage policy .: app-pin
508 PIN retry counter : - [verified] -
509 PIV authentication: 213D1825FDE0F8240CB4E4229F01AF90AC658C2E
510       keyref .....: PIV.9A  (auth)
511       algorithm ..: nistp384
512 Card authenticat. : 7A53E6CFFE7220A0E646B4632EE29E5A7104499C
513       keyref .....: PIV.9E  (auth)
514       algorithm ..: nistp256
515 Digital signature : 32A6C6FAFCB8421878608AAB452D5470DD3223ED
516       keyref .....: PIV.9C  (sign,cert)
517       algorithm ..: rsa2048
518       used for ...: X.509
519         user id ..: CN=Signing key for yk-9074625,O=example,C=DE
520         user id ..: <otto@@example.net>
521 Key management ...: 34798AAFE0A7565088101CC4AE31C5C8C74461CB
522       keyref .....: PIV.9D  (encr)
523       algorithm ..: rsa2048
524       used for ...: X.509
525         user id ..: CN=Encryption key for yk-9074625,O=example,C=DE
526         user id ..: <otto@@example.net>
527 @end example
528
529 It is now possible to sign and to encrypt with this card using gpgsm
530 and to use the @samp{PIV authentication} key with ssh:
531
532 @example
533 $ ssh-add -l
534 384 SHA256:0qnJ0Y0ehWxKcx2frLfEljf6GCdlO55OZed5HqGHsaU cardno:yk-9074625 (ECDSA)
535 @end example
536
537 As usual use ssh-add with the uppercase @samp{-L} to list the public
538 ssh key.  To use the certificates with Thunderbird or Mozilla, please
539 consult the Scute manual for details.
540
541 If you want to use the same PIV keys also for OpenPGP (for example on
542 a Yubikey to avoid switching between OpenPGP and PIV), this is also
543 possible:
544
545 @example
546 $ gpgsm --learn
547 $ gpg --full-gen-key
548 Please select what kind of key you want:
549    (1) RSA and RSA (default)
550    (2) DSA and Elgamal
551    (3) DSA (sign only)
552    (4) RSA (sign only)
553   (14) Existing key from card
554 Your selection? 14
555 Serial number of the card: FF020001008A77C1
556 Available keys:
557    (1) 213D1825FDE0F8240CB4E4229F01AF90AC658C2E PIV.9A nistp384 (auth)
558    (2) 7A53E6CFFE7220A0E646B4632EE29E5A7104499C PIV.9E nistp256 (auth)
559    (3) 32A6C6FAFCB8421878608AAB452D5470DD3223ED PIV.9C rsa2048 (cert,sign)
560    (4) 34798AAFE0A7565088101CC4AE31C5C8C74461CB PIV.9D rsa2048 (encr)
561 Your selection? 3
562 Please specify how long the key should be valid.
563          0 = key does not expire
564       <n>  = key expires in n days
565       <n>w = key expires in n weeks
566       <n>m = key expires in n months
567       <n>y = key expires in n years
568 Key is valid for? (0)
569 Key does not expire at all
570 Is this correct? (y/N) y
571
572 GnuPG needs to construct a user ID to identify your key.
573
574 Real name:
575 Email address: otto@@example.net
576 Comment:
577 You selected this USER-ID:
578     "otto@@example.net"
579
580 Change (N)ame, (C)omment, (E)mail or (O)kay/(Q)uit? o
581 gpg: key C3AFA9ED971BB365 marked as ultimately trusted
582 gpg: revocation certificate stored as '[...]D971BB365.rev'
583 public and secret key created and signed.
584
585 Note that this key cannot be used for encryption.  You may want to use
586 the command "--edit-key" to generate a subkey for this purpose.
587 pub   rsa2048 2019-04-04 [SC]
588       7F899AE2FB73159DD68A1B20C3AFA9ED971BB365
589 uid                      otto@@example.net
590 @end example
591
592 Note that you will be asked two times to enter the PIN of your PIV
593 card.  If you run @command{gpg} in @option{--expert} mode you will
594 also ge given the option to change the usage flags of the key.  The next
595 typescript shows how to add the encryption subkey:
596
597 @example
598 $ gpg --edit-key 7F899AE2FB73159DD68A1B20C3AFA9ED971BB365
599 Secret key is available.
600
601 sec  rsa2048/C3AFA9ED971BB365
602      created: 2019-04-04  expires: never       usage: SC
603      card-no: FF020001008A77C1
604      trust: ultimate      validity: ultimate
605 [ultimate] (1). otto@@example.net
606 gpg> addkey
607 Secret parts of primary key are stored on-card.
608 Please select what kind of key you want:
609    (3) DSA (sign only)
610    (4) RSA (sign only)
611    (5) Elgamal (encrypt only)
612    (6) RSA (encrypt only)
613   (14) Existing key from card
614 Your selection? 14
615 Serial number of the card: FF020001008A77C1
616 Available keys:
617    (1) 213D1825FDE0F8240CB4E4229F01AF90AC658C2E PIV.9A nistp384 (auth)
618    (2) 7A53E6CFFE7220A0E646B4632EE29E5A7104499C PIV.9E nistp256 (auth)
619    (3) 32A6C6FAFCB8421878608AAB452D5470DD3223ED PIV.9C rsa2048 (cert,sign)
620    (4) 34798AAFE0A7565088101CC4AE31C5C8C74461CB PIV.9D rsa2048 (encr)
621 Your selection? 4
622 Please specify how long the key should be valid.
623          0 = key does not expire
624       <n>  = key expires in n days
625       <n>w = key expires in n weeks
626       <n>m = key expires in n months
627       <n>y = key expires in n years
628 Key is valid for? (0)
629 Key does not expire at all
630 Is this correct? (y/N) y
631 Really create? (y/N) y
632
633 sec  rsa2048/C3AFA9ED971BB365
634      created: 2019-04-04  expires: never       usage: SC
635      card-no: FF020001008A77C1
636      trust: ultimate      validity: ultimate
637 ssb  rsa2048/7067860A98FCE6E1
638      created: 2019-04-04  expires: never       usage: E
639      card-no: FF020001008A77C1
640 [ultimate] (1). otto@@example.net
641
642 gpg> save
643 @end example
644
645 Now you can use your PIV card also with @command{gpg}.
646
647 @c @mansect examples
648
649 @mansect see also
650 @ifset isman
651 @command{scdaemon}(1)
652 @end ifset