doc: Note that the persistant passphrase format is unimplemented.
[gnupg.git] / agent / keyformat.txt
1 keyformat.txt (wk 2001-12-18)
2 -----------------------------
3
4
5 Some notes on the format of the secret keys used with gpg-agent.
6
7 Location of keys
8 ================
9 The secret keys[1] are stored on a per file basis in a directory below
10 the ~/.gnupg home directory.  This directory is named
11
12    private-keys-v1.d
13
14 and should have permissions 700.
15
16 The secret keys are stored in files with a name matching the
17 hexadecimal representation of the keygrip[2] and suffixed with ".key".
18
19
20 Unprotected Private Key Format
21 ==============================
22 The content of the file is an S-Expression like the ones used with
23 Libgcrypt.  Here is an example of an unprotected file:
24
25 (private-key
26  (rsa
27   (n #00e0ce9..[some bytes not shown]..51#)
28   (e #010001#)
29   (d #046129F..[some bytes not shown]..81#)
30   (p #00e861b..[some bytes not shown]..f1#)
31   (q #00f7a7c..[some bytes not shown]..61#)
32   (u #304559a..[some bytes not shown]..9b#)
33  )
34  (created-at timestamp)
35  (uri http://foo.bar x-foo:whatever_you_want)
36  (comment whatever)
37 )
38
39 "comment", "created-at" and "uri" are optional.  "comment" is
40 currently used to keep track of ssh key comments. "created-at" is used
41 to keep track of the creation time stamp used with OpenPGP keys; it is
42 optional but required for some operations to calculate the fingerprint
43 of the key.  This timestamp should be a string with the number of
44 seconds since Epoch or an ISO time string (yyyymmddThhmmss).
45
46 Actually this form should not be used for regular purposes and only
47 accepted by gpg-agent with the configuration option:
48 --allow-non-canonical-key-format.  The regular way to represent the
49 keys is in canonical representation[3]:
50
51 (private-key
52    (rsa
53     (n #00e0ce9..[some bytes not shown]..51#)
54     (e #010001#)
55     (d #046129F..[some bytes not shown]..81#)
56     (p #00e861b..[some bytes not shown]..f1#)
57     (q #00f7a7c..[some bytes not shown]..61#)
58     (u #304559a..[some bytes not shown]..9b#)
59    )
60    (uri http://foo.bar x-foo:whatever_you_want)
61 )
62
63
64 Protected Private Key Format
65 ==============================
66 A protected key is like this:
67
68 (protected-private-key
69    (rsa
70     (n #00e0ce9..[some bytes not shown]..51#)
71     (e #010001#)
72     (protected mode (parms) encrypted_octet_string)
73     (protected-at <isotimestamp>)
74    )
75    (uri http://foo.bar x-foo:whatever_you_want)
76    (comment whatever)
77 )
78
79
80 In this scheme the encrypted_octet_string is encrypted according to
81 the algorithm described after the keyword protected; most protection
82 algorithms need some parameters, which are given in a list before the
83 encrypted_octet_string.  The result of the decryption process is a
84 list of the secret key parameters.  The protected-at expression is
85 optional; the isotimestamp is 15 bytes long (e.g. "19610711T172000").
86
87 The currently defined protection modes are:
88
89 1. openpgp-s2k3-sha1-aes-cbc
90
91   This describes an algorithm using using AES in CBC mode for
92   encryption, SHA-1 for integrity protection and the String to Key
93   algorithm 3 from OpenPGP (rfc2440).
94
95   Example:
96
97   (protected openpgp-s2k3-sha1-aes-cbc
98     ((sha1 16byte_salt no_of_iterations) 16byte_iv)
99     encrypted_octet_string
100   )
101
102   The encrypted_octet string should yield this S-Exp (in canonical
103   representation) after decryption:
104
105   (
106    (
107     (d #046129F..[some bytes not shown]..81#)
108     (p #00e861b..[some bytes not shown]..f1#)
109     (q #00f7a7c..[some bytes not shown]..61#)
110     (u #304559a..[some bytes not shown]..9b#)
111    )
112    (hash sha1 #...[hashvalue]...#)
113   )
114
115   For padding reasons, random bytes are appended to this list - they can
116   easily be stripped by looking for the end of the list.
117
118   The hash is calculated on the concatenation of the public key and
119   secret key parameter lists: i.e it is required to hash the
120   concatenation of these 6 canonical encoded lists for RSA, including
121   the parenthesis, the algorithm keyword and (if used) the protected-at
122   list.
123
124   (rsa
125    (n #00e0ce9..[some bytes not shown]..51#)
126    (e #010001#)
127    (d #046129F..[some bytes not shown]..81#)
128    (p #00e861b..[some bytes not shown]..f1#)
129    (q #00f7a7c..[some bytes not shown]..61#)
130    (u #304559a..[some bytes not shown]..9b#)
131    (protected-at "18950523T000000")
132   )
133
134   After decryption the hash must be recalculated and compared against
135   the stored one - If they don't match the integrity of the key is not
136   given.
137
138 2. openpgp-native
139
140   This is a wrapper around the OpenPGP Private Key Transport format
141   which resembles the standard OpenPGP format and allows the use of an
142   existing key without re-encrypting to the default protection format.
143
144   Example:
145
146   (protected openpgp-native
147     (openpgp-private-key
148      (version V)
149      (algo PUBKEYALGO)
150      (skey _ P1 _ P2 _ P3 ... e PN)
151      (csum n)
152      (protection PROTTYPE PROTALGO IV S2KMODE S2KHASH S2KSALT S2KCOUNT)))
153
154   Note that the public key paramaters in SKEY are duplicated and
155   should be identical to their copies in the standard parameter
156   elements.  Here is an example of an entire protected private key
157   using this format:
158
159   (protected-private-key
160    (rsa
161     (n #00e0ce9..[some bytes not shown]..51#)
162     (e #010001#)
163     (protected openpgp-native
164      (openpgp-private-key
165       (version 4)
166       (algo rsa)
167       (skey _ #00e0ce9..[some bytes not shown]..51#
168             _ #010001#
169             e #.........................#)
170       (protection sha1 aes #aabbccddeeff00112233445566778899#
171                   3 sha1 #2596f93e85f41e53# 3:190))))
172    (uri http://foo.bar x-foo:whatever_you_want)
173    (comment whatever))
174
175
176
177 Shadowed Private Key Format
178 ============================
179 To keep track of keys stored on IC cards we use a third format for
180 private kyes which are called shadow keys as they are only a reference
181 to keys stored on a token:
182
183 (shadowed-private-key
184    (rsa
185     (n #00e0ce9..[some bytes not shown]..51#)
186     (e #010001#)
187     (shadowed protocol (info))
188    )
189    (uri http://foo.bar x-foo:whatever_you_want)
190    (comment whatever)
191 )
192
193 The currently used protocol is "ti-v1" (token info version 1).  The
194 second list with the information has this layout:
195
196 (card_serial_number id_string_of_key fixed_pin_length)
197
198 FIXED_PIN_LENGTH is optional.  It can be used to store the length of
199 the PIN; a value of 0 indicates that this information is not
200 available.  The rationale for this field is that some pinpad equipped
201 readers don't allow passing a variable length PIN.
202
203 More items may be added to the list.
204
205
206 OpenPGP Private Key Transfer Format
207 ===================================
208
209 This format is used to transfer keys between gpg and gpg-agent.
210
211 (openpgp-private-key
212   (version V)
213   (algo PUBKEYALGO)
214   (curve CURVENAME)
215   (skey _ P1 _ P2 _ P3 ... e PN)
216   (csum n)
217   (protection PROTTYPE PROTALGO IV S2KMODE S2KHASH S2KSALT S2KCOUNT))
218
219
220 * V is the packet version number (3 or 4).
221 * PUBKEYALGO is a Libgcrypt algo name
222 * CURVENAME is the name of the curve - only used with ECC.
223 * P1 .. PN are the parameters; the public parameters are never encrypted
224   the secrect key parameters are encrypted if the "protection" list is
225   given.  To make this more explicit each parameter is preceded by a
226   flag "_" for cleartext or "e" for encrypted text.
227 * CSUM is the deprecated 16 bit checksum as defined by OpenPGP.  This
228   is an optional element.
229 * If PROTTYPE is "sha1" the new style SHA1 checksum is used if it is "sum"
230   the old 16 bit checksum (above) is used and if it is "none" no
231   protection at all is used.
232 * PROTALGO is a Libgcrypt style cipher algorithm name
233 * IV is the initialization verctor.
234 * S2KMODE is the value from RFC-4880.
235 * S2KHASH is a a libgcrypt style hash algorithm identifier.
236 * S2KSALT is the 8 byte salt
237 * S2KCOUNT is the count value from RFC-4880.
238
239
240 Persistent Passphrase Format
241 ============================
242
243 Note: That this has not yet been implemented.
244
245 To allow persistent storage of cached passphrases we use a scheme
246 similar to the private-key storage format.  This is a master
247 passphrase format where each file may protect several secrets under
248 one master passphrase.  It is possible to have several of those files
249 each protected by a dedicated master passphrase.  Clear text keywords
250 allow to list the available protected passphrases.
251
252 The name of the files with these protected secrets have this form:
253 pw-<string>.dat.  STRING may be an arbitrary string, as a default name
254 for the passphrase storage the name "pw-default.dat" is suggested.
255
256
257 (protected-shared-secret
258    ((desc descriptive_text)
259     (key [key_1] (keyword_1 keyword_2 keyword_n))
260     (key [key_2] (keyword_21 keyword_22 keyword_2n))
261     (key [key_n] (keyword_n1 keyword_n2 keyword_nn))
262     (protected mode (parms) encrypted_octet_string)
263     (protected-at <isotimestamp>)
264    )
265 )
266
267 After decryption the encrypted_octet_string yields this S-expression:
268
269 (
270  (
271   (value key_1 value_1)
272   (value key_2 value_2)
273   (value key_n value_n)
274  )
275  (hash sha1 #...[hashvalue]...#)
276 )
277
278 The "descriptive_text" is displayed with the prompt to enter the
279 unprotection passphrase.
280
281 KEY_1 to KEY_N are unique identifiers for the shared secret, for
282 example an URI.  In case this information should be kept confidential
283 as well, they may not appear in the unprotected part; however they are
284 mandatory in the encrypted_octet_string.  The list of keywords is
285 optional.  The oder of the "key" lists and the order of the "value"
286 lists mut match, that is the first "key"-list is associated with the
287 first "value" list in the encrypted_octet_string.
288
289 The protection mode etc. is indentical to the protection mode as
290 decribed for the private key format.
291
292 list of the secret key parameters.  The protected-at expression is
293 optional; the isotimestamp is 15 bytes long (e.g. "19610711T172000").
294
295 The "hash" in the encrypted_octet_string is calculated on the
296 concatenation of the key list and value lists: i.e it is required to
297 hash the concatenation of all these lists, including the
298 parenthesis and (if used) the protected-at list.
299
300 Example:
301
302 (protected-shared-secret
303    ((desc "List of system passphrases")
304     (key "uid-1002" ("Knuth" "Donald Ervin Knuth"))
305     (key "uid-1001" ("Dijkstra" "Edsgar Wybe Dijkstra"))
306     (key)
307     (protected mode (parms) encrypted_octet_string)
308     (protected-at "20100915T111722")
309    )
310 )
311
312 with "encrypted_octet_string" decoding to:
313
314 (
315  (
316   (value 4:1002 "signal flags at the lock")
317   (value 4:1001 "taocp")
318   (value 1:0    "premature optimization is the root of all evil")
319  )
320  (hash sha1 #0102030405060708091011121314151617181920#)
321 )
322
323 To compute the hash this S-expression (in canoncical format) was
324 hashed:
325
326    ((desc "List of system passphrases")
327     (key "uid-1002" ("Knuth" "Donald Ervin Knuth"))
328     (key "uid-1001" ("Dijkstra" "Edsgar Wybe Dijkstra"))
329     (key)
330     (value 4:1002 "signal flags at the lock")
331     (value 4:1001 "taocp")
332     (value 1:0    "premature optimization is the root of all evil")
333     (protected-at "20100915T111722")
334    )
335
336
337
338
339
340
341
342 Notes:
343 ======
344 [1] I usually use the terms private and secret key exchangeable but prefer the
345 term secret key because it can be visually be better distinguished
346 from the term public key.
347
348 [2] The keygrip is a unique identifier for a key pair, it is
349 independent of any protocol, so that the same key can be used with
350 different protocols.  PKCS-15 calls this a subjectKeyHash; it can be
351 calculated using Libgcrypt's gcry_pk_get_keygrip ().
352
353 [3] Even when canonical representation are required we will show the
354 S-expression here in a more readable representation.