pyrox.dev
1# See: https://wiki.strongswan.org/projects/strongswan/wiki/Swanctlconf
2#
3# When strongSwan is upgraded please update the parameters in this file. You can
4# see which parameters should be deleted, changed or added by diffing
5# swanctl.opt:
6#
7# git clone https://github.com/strongswan/strongswan.git
8# cd strongswan
9# git diff 5.7.2..5.8.0 src/swanctl/swanctl.opt
10
11lib: with (import ./param-constructors.nix lib);
12
13let
14 certParams = {
15 file = mkOptionalStrParam ''
16 Absolute path to the certificate to load. Passed as-is to the daemon, so
17 it must be readable by it.
18
19 Configure either this or {option}`handle`, but not both, in one section.
20 '';
21
22 handle = mkOptionalHexParam ''
23 Hex-encoded CKA_ID or handle of the certificate on a token or TPM,
24 respectively.
25
26 Configure either this or {option}`file`, but not both, in one section.
27 '';
28
29 slot = mkOptionalIntParam ''
30 Optional slot number of the token that stores the certificate.
31 '';
32
33 module = mkOptionalStrParam ''
34 Optional PKCS#11 module name.
35 '';
36 };
37in {
38 authorities = mkAttrsOfParams ({
39
40 cacert = mkOptionalStrParam ''
41 The certificates may use a relative path from the swanctl
42 `x509ca` directory or an absolute path.
43
44 Configure one of {option}`cacert`,
45 {option}`file`, or
46 {option}`handle` per section.
47 '';
48
49 cert_uri_base = mkOptionalStrParam ''
50 Defines the base URI for the Hash and URL feature supported by
51 IKEv2. Instead of exchanging complete certificates, IKEv2 allows one to
52 send an URI that resolves to the DER encoded certificate. The certificate
53 URIs are built by appending the SHA1 hash of the DER encoded certificates
54 to this base URI.
55 '';
56
57 crl_uris = mkCommaSepListParam [] ''
58 List of CRL distribution points (ldap, http, or file URI).
59 '';
60
61 ocsp_uris = mkCommaSepListParam [] ''
62 List of OCSP URIs.
63 '';
64
65 } // certParams) ''
66 Section defining complementary attributes of certification authorities, each
67 in its own subsection with an arbitrary yet unique name
68 '';
69
70 connections = mkAttrsOfParams {
71
72 version = mkIntParam 0 ''
73 IKE major version to use for connection.
74
75 - 1 uses IKEv1 aka ISAKMP,
76 - 2 uses IKEv2.
77 - A connection using the default of 0 accepts both IKEv1 and IKEv2 as
78 responder, and initiates the connection actively with IKEv2.
79 '';
80
81 local_addrs = mkCommaSepListParam [] ''
82 Local address(es) to use for IKE communication. Takes
83 single IPv4/IPv6 addresses, DNS names, CIDR subnets or IP address ranges.
84
85 As initiator, the first non-range/non-subnet is used to initiate the
86 connection from. As responder, the local destination address must match at
87 least to one of the specified addresses, subnets or ranges.
88
89 If FQDNs are assigned they are resolved every time a configuration lookup
90 is done. If DNS resolution times out, the lookup is delayed for that time.
91 '';
92
93 remote_addrs = mkCommaSepListParam [] ''
94 Remote address(es) to use for IKE communication. Takes
95 single IPv4/IPv6 addresses, DNS names, CIDR subnets or IP address ranges.
96
97 As initiator, the first non-range/non-subnet is used to initiate the
98 connection to. As responder, the initiator source address must match at
99 least to one of the specified addresses, subnets or ranges.
100
101 If FQDNs are assigned they are resolved every time a configuration lookup
102 is done. If DNS resolution times out, the lookup is delayed for that time.
103 To initiate a connection, at least one specific address or DNS name must
104 be specified.
105 '';
106
107 local_port = mkIntParam 500 ''
108 Local UDP port for IKE communication. By default the port of the socket
109 backend is used, which is usually `500`. If port
110 `500` is used, automatic IKE port floating to port
111 `4500` is used to work around NAT issues.
112
113 Using a non-default local IKE port requires support from the socket
114 backend in use (socket-dynamic).
115 '';
116
117 remote_port = mkIntParam 500 ''
118 Remote UDP port for IKE communication. If the default of port
119 `500` is used, automatic IKE port floating to port
120 `4500` is used to work around NAT issues.
121 '';
122
123 proposals = mkCommaSepListParam ["default"] ''
124 A proposal is a set of algorithms. For non-AEAD algorithms, this includes
125 for IKE an encryption algorithm, an integrity algorithm, a pseudo random
126 function and a Diffie-Hellman group. For AEAD algorithms, instead of
127 encryption and integrity algorithms, a combined algorithm is used.
128
129 In IKEv2, multiple algorithms of the same kind can be specified in a
130 single proposal, from which one gets selected. In IKEv1, only one
131 algorithm per kind is allowed per proposal, more algorithms get implicitly
132 stripped. Use multiple proposals to offer different algorithms
133 combinations in IKEv1.
134
135 Algorithm keywords get separated using dashes. Multiple proposals may be
136 specified in a list. The special value `default` forms a
137 default proposal of supported algorithms considered safe, and is usually a
138 good choice for interoperability.
139 '';
140
141 vips = mkCommaSepListParam [] ''
142 List of virtual IPs to request in IKEv2 configuration payloads or IKEv1
143 Mode Config. The wildcard addresses `0.0.0.0` and
144 `::` request an arbitrary address, specific addresses may
145 be defined. The responder may return a different address, though, or none
146 at all.
147 '';
148
149 aggressive = mkYesNoParam no ''
150 Enables Aggressive Mode instead of Main Mode with Identity
151 Protection. Aggressive Mode is considered less secure, because the ID and
152 HASH payloads are exchanged unprotected. This allows a passive attacker to
153 snoop peer identities, and even worse, start dictionary attacks on the
154 Preshared Key.
155 '';
156
157 pull = mkYesNoParam yes ''
158 If the default of yes is used, Mode Config works in pull mode, where the
159 initiator actively requests a virtual IP. With no, push mode is used,
160 where the responder pushes down a virtual IP to the initiating peer.
161
162 Push mode is currently supported for IKEv1, but not in IKEv2. It is used
163 by a few implementations only, pull mode is recommended.
164 '';
165
166 dscp = mkStrParam "000000" ''
167 Differentiated Services Field Codepoint to set on outgoing IKE packets for
168 this connection. The value is a six digit binary encoded string specifying
169 the Codepoint to set, as defined in RFC 2474.
170 '';
171
172 encap = mkYesNoParam no ''
173 To enforce UDP encapsulation of ESP packets, the IKE daemon can fake the
174 NAT detection payloads. This makes the peer believe that NAT takes place
175 on the path, forcing it to encapsulate ESP packets in UDP.
176
177 Usually this is not required, but it can help to work around connectivity
178 issues with too restrictive intermediary firewalls.
179 '';
180
181 mobike = mkYesNoParam yes ''
182 Enables MOBIKE on IKEv2 connections. MOBIKE is enabled by default on IKEv2
183 connections, and allows mobility of clients and multi-homing on servers by
184 migrating active IPsec tunnels.
185
186 Usually keeping MOBIKE enabled is unproblematic, as it is not used if the
187 peer does not indicate support for it. However, due to the design of
188 MOBIKE, IKEv2 always floats to port 4500 starting from the second
189 exchange. Some implementations don't like this behavior, hence it can be
190 disabled.
191 '';
192
193 dpd_delay = mkDurationParam "0s" ''
194 Interval to check the liveness of a peer actively using IKEv2
195 INFORMATIONAL exchanges or IKEv1 R_U_THERE messages. Active DPD checking
196 is only enforced if no IKE or ESP/AH packet has been received for the
197 configured DPD delay.
198 '';
199
200 dpd_timeout = mkDurationParam "0s" ''
201 Charon by default uses the normal retransmission mechanism and timeouts to
202 check the liveness of a peer, as all messages are used for liveness
203 checking. For compatibility reasons, with IKEv1 a custom interval may be
204 specified; this option has no effect on connections using IKEv2.
205 '';
206
207 fragmentation = mkEnumParam ["yes" "accept" "force" "no"] "yes" ''
208 Use IKE fragmentation (proprietary IKEv1 extension or RFC 7383 IKEv2
209 fragmentation). Acceptable values are `yes` (the default
210 since 5.5.1), `accept` (since versions:5.5.3),
211 `force` and `no`.
212
213 - If set to `yes`, and the peer
214 supports it, oversized IKE messages will be sent in fragments.
215 - If set to
216 `accept`, support for fragmentation is announced to the peer but the daemon
217 does not send its own messages in fragments.
218 - If set to `force` (only
219 supported for IKEv1) the initial IKE message will already be fragmented if
220 required.
221 - Finally, setting the option to `no` will disable announcing
222 support for this feature.
223
224 Note that fragmented IKE messages sent by a peer are always processed
225 irrespective of the value of this option (even when set to no).
226 '';
227
228 childless = mkEnumParam [ "allow" "force" "never" ] "allow" ''
229 Use childless IKE_SA initiation (RFC 6023) for IKEv2. Acceptable values
230 are `allow` (the default), `force` and
231 `never`. If set to `allow`, responders
232 will accept childless IKE_SAs (as indicated via notify in the IKE_SA_INIT
233 response) while initiators continue to create regular IKE_SAs with the
234 first CHILD_SA created during IKE_AUTH, unless the IKE_SA is initiated
235 explicitly without any children (which will fail if the responder does not
236 support or has disabled this extension). If set to
237 `force`, only childless initiation is accepted and the
238 first CHILD_SA is created with a separate CREATE_CHILD_SA exchange
239 (e.g. to use an independent DH exchange for all CHILD_SAs). Finally,
240 setting the option to `never` disables support for
241 childless IKE_SAs as responder.
242 '';
243
244 send_certreq = mkYesNoParam yes ''
245 Send certificate request payloads to offer trusted root CA certificates to
246 the peer. Certificate requests help the peer to choose an appropriate
247 certificate/private key for authentication and are enabled by default.
248 Disabling certificate requests can be useful if too many trusted root CA
249 certificates are installed, as each certificate request increases the size
250 of the initial IKE packets.
251 '';
252
253 send_cert = mkEnumParam ["always" "never" "ifasked" ] "ifasked" ''
254 Send certificate payloads when using certificate authentication.
255
256 - With the default of `ifasked` the daemon sends
257 certificate payloads only if certificate requests have been received.
258 - `never` disables sending of certificate payloads
259 altogether,
260 - `always` causes certificate payloads to be sent
261 unconditionally whenever certificate authentication is used.
262 '';
263
264 ppk_id = mkOptionalStrParam ''
265 String identifying the Postquantum Preshared Key (PPK) to be used.
266 '';
267
268 ppk_required = mkYesNoParam no ''
269 Whether a Postquantum Preshared Key (PPK) is required for this connection.
270 '';
271
272 keyingtries = mkIntParam 1 ''
273 Number of retransmission sequences to perform during initial
274 connect. Instead of giving up initiation after the first retransmission
275 sequence with the default value of `1`, additional
276 sequences may be started according to the configured value. A value of
277 `0` initiates a new sequence until the connection
278 establishes or fails with a permanent error.
279 '';
280
281 unique = mkEnumParam ["no" "never" "keep" "replace"] "no" ''
282 Connection uniqueness policy to enforce. To avoid multiple connections
283 from the same user, a uniqueness policy can be enforced.
284
285 - The value `never` does never enforce such a policy, even
286 if a peer included INITIAL_CONTACT notification messages,
287 - whereas `no` replaces existing connections for the same
288 identity if a new one has the INITIAL_CONTACT notify.
289 - `keep` rejects new connection attempts if the same user
290 already has an active connection,
291 - `replace` deletes any existing connection if a new one
292 for the same user gets established.
293
294 To compare connections for uniqueness, the remote IKE identity is used. If
295 EAP or XAuth authentication is involved, the EAP-Identity or XAuth
296 username is used to enforce the uniqueness policy instead.
297
298 On initiators this setting specifies whether an INITIAL_CONTACT notify is
299 sent during IKE_AUTH if no existing connection is found with the remote
300 peer (determined by the identities of the first authentication
301 round). Unless set to `never` the client will send a notify.
302 '';
303
304 reauth_time = mkDurationParam "0s" ''
305 Time to schedule IKE reauthentication. IKE reauthentication recreates the
306 IKE/ISAKMP SA from scratch and re-evaluates the credentials. In asymmetric
307 configurations (with EAP or configuration payloads) it might not be
308 possible to actively reauthenticate as responder. The IKEv2
309 reauthentication lifetime negotiation can instruct the client to perform
310 reauthentication.
311
312 Reauthentication is disabled by default. Enabling it usually may lead to
313 small connection interruptions, as strongSwan uses a break-before-make
314 policy with IKEv2 to avoid any conflicts with associated tunnel resources.
315 '';
316
317 rekey_time = mkDurationParam "4h" ''
318 IKE rekeying refreshes key material using a Diffie-Hellman exchange, but
319 does not re-check associated credentials. It is supported in IKEv2 only,
320 IKEv1 performs a reauthentication procedure instead.
321
322 With the default value IKE rekeying is scheduled every 4 hours, minus the
323 configured rand_time. If a reauth_time is configured, rekey_time defaults
324 to zero, disabling rekeying; explicitly set both to enforce rekeying and
325 reauthentication.
326 '';
327
328 over_time = mkOptionalDurationParam ''
329 Hard IKE_SA lifetime if rekey/reauth does not complete, as time. To avoid
330 having an IKE/ISAKMP kept alive if IKE reauthentication or rekeying fails
331 perpetually, a maximum hard lifetime may be specified. If the IKE_SA fails
332 to rekey or reauthenticate within the specified time, the IKE_SA gets
333 closed.
334
335 In contrast to CHILD_SA rekeying, over_time is relative in time to the
336 rekey_time and reauth_time values, as it applies to both.
337
338 The default is 10% of the longer of {option}`rekey_time` and
339 {option}`reauth_time`.
340 '';
341
342 rand_time = mkOptionalDurationParam ''
343 Time range from which to choose a random value to subtract from
344 rekey/reauth times. To avoid having both peers initiating the rekey/reauth
345 procedure simultaneously, a random time gets subtracted from the
346 rekey/reauth times.
347
348 The default is equal to the configured {option}`over_time`.
349 '';
350
351 pools = mkCommaSepListParam [] ''
352 List of named IP pools to allocate virtual IP addresses
353 and other configuration attributes from. Each name references a pool by
354 name from either the pools section or an external pool.
355 '';
356
357 if_id_in = mkStrParam "0" ''
358 XFRM interface ID set on inbound policies/SA, can be overridden by child
359 config, see there for details.
360 '';
361
362 if_id_out = mkStrParam "0" ''
363 XFRM interface ID set on outbound policies/SA, can be overridden by child
364 config, see there for details.
365 '';
366
367 mediation = mkYesNoParam no ''
368 Whether this connection is a mediation connection, that is, whether this
369 connection is used to mediate other connections using the IKEv2 Mediation
370 Extension. Mediation connections create no CHILD_SA.
371 '';
372
373 mediated_by = mkOptionalStrParam ''
374 The name of the connection to mediate this connection through. If given,
375 the connection will be mediated through the named mediation
376 connection. The mediation connection must have mediation enabled.
377 '';
378
379 mediation_peer = mkOptionalStrParam ''
380 Identity under which the peer is registered at the mediation server, that
381 is, the IKE identity the other end of this connection uses as its local
382 identity on its connection to the mediation server. This is the identity
383 we request the mediation server to mediate us with. Only relevant on
384 connections that set mediated_by. If it is not given, the remote IKE
385 identity of the first authentication round of this connection will be
386 used.
387 '';
388
389 local = mkPrefixedAttrsOfParams {
390
391 round = mkIntParam 0 ''
392 Optional numeric identifier by which authentication rounds are
393 sorted. If not specified rounds are ordered by their position in the
394 config file/vici message.
395 '';
396
397 certs = mkCommaSepListParam [] ''
398 List of certificate candidates to use for
399 authentication. The certificates may use a relative path from the
400 swanctl `x509` directory or an absolute path.
401
402 The certificate used for authentication is selected based on the
403 received certificate request payloads. If no appropriate CA can be
404 located, the first certificate is used.
405 '';
406
407 cert = mkPostfixedAttrsOfParams certParams ''
408 Section for a certificate candidate to use for
409 authentication. Certificates in certs are transmitted as binary blobs,
410 these sections offer more flexibility.
411 '';
412
413 pubkeys = mkCommaSepListParam [] ''
414 List of raw public key candidates to use for
415 authentication. The public keys may use a relative path from the swanctl
416 `pubkey` directory or an absolute path.
417
418 Even though multiple local public keys could be defined in principle,
419 only the first public key in the list is used for authentication.
420 '';
421
422 auth = mkStrParam "pubkey" ''
423 Authentication to perform locally.
424
425 - The default `pubkey` uses public key authentication
426 using a private key associated to a usable certificate.
427 - `psk` uses pre-shared key authentication.
428 - The IKEv1 specific `xauth` is used for XAuth or Hybrid
429 authentication,
430 - while the IKEv2 specific `eap` keyword defines EAP
431 authentication.
432 - For `xauth`, a specific backend name may be appended,
433 separated by a dash. The appropriate `xauth` backend is
434 selected to perform the XAuth exchange. For traditional XAuth, the
435 `xauth` method is usually defined in the second
436 authentication round following an initial `pubkey` (or
437 `psk`) round. Using `xauth` in the
438 first round performs Hybrid Mode client authentication.
439 - For `eap`, a specific EAP method name may be appended, separated by a
440 dash. An EAP module implementing the appropriate method is selected to
441 perform the EAP conversation.
442 - Since 5.4.0, if both peers support RFC 7427 ("Signature Authentication
443 in IKEv2") specific hash algorithms to be used during IKEv2
444 authentication may be configured. To do so use `ike:`
445 followed by a trust chain signature scheme constraint (see description
446 of the {option}`remote` section's {option}`auth`
447 keyword). For example, with `ike:pubkey-sha384-sha256`
448 a public key signature scheme with either SHA-384 or SHA-256 would get
449 used for authentication, in that order and depending on the hash
450 algorithms supported by the peer. If no specific hash algorithms are
451 configured, the default is to prefer an algorithm that matches or
452 exceeds the strength of the signature key. If no constraints with
453 `ike:` prefix are configured any signature scheme
454 constraint (without `ike:` prefix) will also apply to
455 IKEv2 authentication, unless this is disabled in
456 `strongswan.conf`. To use RSASSA-PSS signatures use
457 `rsa/pss` instead of `pubkey` or
458 `rsa` as in e.g.
459 `ike:rsa/pss-sha256`. If `pubkey` or
460 `rsa` constraints are configured RSASSA-PSS signatures
461 will only be used if enabled in `strongswan.conf`(5).
462 '';
463
464 id = mkOptionalStrParam ''
465 IKE identity to use for authentication round. When using certificate
466 authentication, the IKE identity must be contained in the certificate,
467 either as subject or as subjectAltName.
468 '';
469
470 eap_id = mkOptionalStrParam ''
471 Client EAP-Identity to use in EAP-Identity exchange and the EAP method.
472 '';
473
474 aaa_id = mkOptionalStrParam ''
475 Server side EAP-Identity to expect in the EAP method. Some EAP methods,
476 such as EAP-TLS, use an identity for the server to perform mutual
477 authentication. This identity may differ from the IKE identity,
478 especially when EAP authentication is delegated from the IKE responder
479 to an AAA backend.
480
481 For EAP-(T)TLS, this defines the identity for which the server must
482 provide a certificate in the TLS exchange.
483 '';
484
485 xauth_id = mkOptionalStrParam ''
486 Client XAuth username used in the XAuth exchange.
487 '';
488
489 } ''
490 Section for a local authentication round. A local authentication round
491 defines the rules how authentication is performed for the local
492 peer. Multiple rounds may be defined to use IKEv2 RFC 4739 Multiple
493 Authentication or IKEv1 XAuth.
494
495 Each round is defined in a section having `local` as
496 prefix, and an optional unique suffix. To define a single authentication
497 round, the suffix may be omitted.
498 '';
499
500 remote = mkPrefixedAttrsOfParams {
501
502 round = mkIntParam 0 ''
503 Optional numeric identifier by which authentication rounds are
504 sorted. If not specified rounds are ordered by their position in the
505 config file/vici message.
506 '';
507
508 id = mkStrParam "%any" ''
509 IKE identity to expect for authentication round. When using certificate
510 authentication, the IKE identity must be contained in the certificate,
511 either as subject or as subjectAltName.
512 '';
513
514 eap_id = mkOptionalStrParam ''
515 Identity to use as peer identity during EAP authentication. If set to
516 `%any` the EAP-Identity method will be used to ask the
517 client for an EAP identity.
518 '';
519
520 groups = mkCommaSepListParam [] ''
521 Authorization group memberships to require. The peer
522 must prove membership to at least one of the specified groups. Group
523 membership can be certified by different means, for example by
524 appropriate Attribute Certificates or by an AAA backend involved in the
525 authentication.
526 '';
527
528 cert_policy = mkCommaSepListParam [] ''
529 List of certificate policy OIDs the peer's certificate
530 must have. OIDs are specified using the numerical dotted representation.
531 '';
532
533 certs = mkCommaSepListParam [] ''
534 List of certificates to accept for authentication. The certificates may
535 use a relative path from the swanctl `x509` directory
536 or an absolute path.
537 '';
538
539 cert = mkPostfixedAttrsOfParams certParams ''
540 Section for a certificate candidate to use for
541 authentication. Certificates in certs are transmitted as binary blobs,
542 these sections offer more flexibility.
543 '';
544
545 ca_id = mkOptionalStrParam ''
546 Identity in CA certificate to accept for authentication. The specified
547 identity must be contained in one (intermediate) CA of the remote peer
548 trustchain, either as subject or as subjectAltName. This has the same
549 effect as specifying `cacerts` to force clients under
550 a CA to specific connections; it does not require the CA certificate
551 to be available locally, and can be received from the peer during the
552 IKE exchange.
553 '';
554
555 cacerts = mkCommaSepListParam [] ''
556 List of CA certificates to accept for
557 authentication. The certificates may use a relative path from the
558 swanctl `x509ca` directory or an absolute path.
559 '';
560
561 cacert = mkPostfixedAttrsOfParams certParams ''
562 Section for a CA certificate to accept for authentication. Certificates
563 in cacerts are transmitted as binary blobs, these sections offer more
564 flexibility.
565 '';
566
567 pubkeys = mkCommaSepListParam [] ''
568 List of raw public keys to accept for
569 authentication. The public keys may use a relative path from the swanctl
570 `pubkey` directory or an absolute path.
571 '';
572
573 revocation = mkEnumParam ["strict" "ifuri" "relaxed"] "relaxed" ''
574 Certificate revocation policy for CRL or OCSP revocation.
575
576 - A `strict` revocation policy fails if no revocation information is
577 available, i.e. the certificate is not known to be unrevoked.
578 - `ifuri` fails only if a CRL/OCSP URI is available, but certificate
579 revocation checking fails, i.e. there should be revocation information
580 available, but it could not be obtained.
581 - The default revocation policy `relaxed` fails only if a certificate is
582 revoked, i.e. it is explicitly known that it is bad.
583 '';
584
585 auth = mkStrParam "pubkey" ''
586 Authentication to expect from remote. See the {option}`local`
587 section's {option}`auth` keyword description about the details of
588 supported mechanisms.
589
590 Since 5.4.0, to require a trustchain public key strength for the remote
591 side, specify the key type followed by the minimum strength in bits (for
592 example `ecdsa-384` or
593 `rsa-2048-ecdsa-256`). To limit the acceptable set of
594 hashing algorithms for trustchain validation, append hash algorithms to
595 pubkey or a key strength definition (for example
596 `pubkey-sha256-sha512`,
597 `rsa-2048-sha256-sha384-sha512` or
598 `rsa-2048-sha256-ecdsa-256-sha256-sha384`).
599 Unless disabled in `strongswan.conf`, or explicit IKEv2
600 signature constraints are configured (refer to the description of the
601 {option}`local` section's {option}`auth` keyword for
602 details), such key types and hash algorithms are also applied as
603 constraints against IKEv2 signature authentication schemes used by the
604 remote side. To require RSASSA-PSS signatures use
605 `rsa/pss` instead of `pubkey` or
606 `rsa` as in e.g. `rsa/pss-sha256`. If
607 `pubkey` or `rsa` constraints are
608 configured RSASSA-PSS signatures will only be accepted if enabled in
609 `strongswan.conf`(5).
610
611 To specify trust chain constraints for EAP-(T)TLS, append a colon to the
612 EAP method, followed by the key type/size and hash algorithm as
613 discussed above (e.g. `eap-tls:ecdsa-384-sha384`).
614 '';
615
616 } ''
617 Section for a remote authentication round. A remote authentication round
618 defines the constraints how the peers must authenticate to use this
619 connection. Multiple rounds may be defined to use IKEv2 RFC 4739 Multiple
620 Authentication or IKEv1 XAuth.
621
622 Each round is defined in a section having `remote` as
623 prefix, and an optional unique suffix. To define a single authentication
624 round, the suffix may be omitted.
625 '';
626
627 children = mkAttrsOfParams {
628 ah_proposals = mkCommaSepListParam [] ''
629 AH proposals to offer for the CHILD_SA. A proposal is a set of
630 algorithms. For AH, this includes an integrity algorithm and an optional
631 Diffie-Hellman group. If a DH group is specified, CHILD_SA/Quick Mode
632 rekeying and initial negotiation uses a separate Diffie-Hellman exchange
633 using the specified group (refer to esp_proposals for details).
634
635 In IKEv2, multiple algorithms of the same kind can be specified in a
636 single proposal, from which one gets selected. In IKEv1, only one
637 algorithm per kind is allowed per proposal, more algorithms get
638 implicitly stripped. Use multiple proposals to offer different algorithms
639 combinations in IKEv1.
640
641 Algorithm keywords get separated using dashes. Multiple proposals may be
642 specified in a list. The special value `default` forms
643 a default proposal of supported algorithms considered safe, and is
644 usually a good choice for interoperability. By default no AH proposals
645 are included, instead ESP is proposed.
646 '';
647
648 esp_proposals = mkCommaSepListParam ["default"] ''
649 ESP proposals to offer for the CHILD_SA. A proposal is a set of
650 algorithms. For ESP non-AEAD proposals, this includes an integrity
651 algorithm, an encryption algorithm, an optional Diffie-Hellman group and
652 an optional Extended Sequence Number Mode indicator. For AEAD proposals,
653 a combined mode algorithm is used instead of the separate
654 encryption/integrity algorithms.
655
656 If a DH group is specified, CHILD_SA/Quick Mode rekeying and initial
657 negotiation use a separate Diffie-Hellman exchange using the specified
658 group. However, for IKEv2, the keys of the CHILD_SA created implicitly
659 with the IKE_SA will always be derived from the IKE_SA's key material. So
660 any DH group specified here will only apply when the CHILD_SA is later
661 rekeyed or is created with a separate CREATE_CHILD_SA exchange. A
662 proposal mismatch might, therefore, not immediately be noticed when the
663 SA is established, but may later cause rekeying to fail.
664
665 Extended Sequence Number support may be indicated with the
666 `esn` and `noesn` values, both may be
667 included to indicate support for both modes. If omitted,
668 `noesn` is assumed.
669
670 In IKEv2, multiple algorithms of the same kind can be specified in a
671 single proposal, from which one gets selected. In IKEv1, only one
672 algorithm per kind is allowed per proposal, more algorithms get
673 implicitly stripped. Use multiple proposals to offer different algorithms
674 combinations in IKEv1.
675
676 Algorithm keywords get separated using dashes. Multiple proposals may be
677 specified as a list. The special value `default` forms
678 a default proposal of supported algorithms considered safe, and is
679 usually a good choice for interoperability. If no algorithms are
680 specified for AH nor ESP, the default set of algorithms for ESP is
681 included.
682 '';
683
684 sha256_96 = mkYesNoParam no ''
685 HMAC-SHA-256 is used with 128-bit truncation with IPsec. For
686 compatibility with implementations that incorrectly use 96-bit truncation
687 this option may be enabled to configure the shorter truncation length in
688 the kernel. This is not negotiated, so this only works with peers that
689 use the incorrect truncation length (or have this option enabled).
690 '';
691
692 local_ts = mkCommaSepListParam ["dynamic"] ''
693 List of local traffic selectors to include in CHILD_SA. Each selector is
694 a CIDR subnet definition, followed by an optional proto/port
695 selector. The special value `dynamic` may be used
696 instead of a subnet definition, which gets replaced by the tunnel outer
697 address or the virtual IP, if negotiated. This is the default.
698
699 A protocol/port selector is surrounded by opening and closing square
700 brackets. Between these brackets, a numeric or getservent(3) protocol
701 name may be specified. After the optional protocol restriction, an
702 optional port restriction may be specified, separated by a slash. The
703 port restriction may be numeric, a getservent(3) service name, or the
704 special value `opaque` for RFC 4301 OPAQUE
705 selectors. Port ranges may be specified as well, none of the kernel
706 backends currently support port ranges, though.
707
708 When IKEv1 is used only the first selector is interpreted, except if the
709 Cisco Unity extension plugin is used. This is due to a limitation of the
710 IKEv1 protocol, which only allows a single pair of selectors per
711 CHILD_SA. So to tunnel traffic matched by several pairs of selectors when
712 using IKEv1 several children (CHILD_SAs) have to be defined that cover
713 the selectors. The IKE daemon uses traffic selector narrowing for IKEv1,
714 the same way it is standardized and implemented for IKEv2. However, this
715 may lead to problems with other implementations. To avoid that, configure
716 identical selectors in such scenarios.
717 '';
718
719 remote_ts = mkCommaSepListParam ["dynamic"] ''
720 List of remote selectors to include in CHILD_SA. See
721 {option}`local_ts` for a description of the selector syntax.
722 '';
723
724 rekey_time = mkDurationParam "1h" ''
725 Time to schedule CHILD_SA rekeying. CHILD_SA rekeying refreshes key
726 material, optionally using a Diffie-Hellman exchange if a group is
727 specified in the proposal. To avoid rekey collisions initiated by both
728 ends simultaneously, a value in the range of {option}`rand_time`
729 gets subtracted to form the effective soft lifetime.
730
731 By default CHILD_SA rekeying is scheduled every hour, minus
732 {option}`rand_time`.
733 '';
734
735 life_time = mkOptionalDurationParam ''
736 Maximum lifetime before CHILD_SA gets closed. Usually this hard lifetime
737 is never reached, because the CHILD_SA gets rekeyed before. If that fails
738 for whatever reason, this limit closes the CHILD_SA. The default is 10%
739 more than the {option}`rekey_time`.
740 '';
741
742 rand_time = mkOptionalDurationParam ''
743 Time range from which to choose a random value to subtract from
744 {option}`rekey_time`. The default is the difference between
745 {option}`life_time` and {option}`rekey_time`.
746 '';
747
748 rekey_bytes = mkIntParam 0 ''
749 Number of bytes processed before initiating CHILD_SA rekeying. CHILD_SA
750 rekeying refreshes key material, optionally using a Diffie-Hellman
751 exchange if a group is specified in the proposal.
752
753 To avoid rekey collisions initiated by both ends simultaneously, a value
754 in the range of {option}`rand_bytes` gets subtracted to form the
755 effective soft volume limit.
756
757 Volume based CHILD_SA rekeying is disabled by default.
758 '';
759
760 life_bytes = mkOptionalIntParam ''
761 Maximum bytes processed before CHILD_SA gets closed. Usually this hard
762 volume limit is never reached, because the CHILD_SA gets rekeyed
763 before. If that fails for whatever reason, this limit closes the
764 CHILD_SA. The default is 10% more than {option}`rekey_bytes`.
765 '';
766
767 rand_bytes = mkOptionalIntParam ''
768 Byte range from which to choose a random value to subtract from
769 {option}`rekey_bytes`. The default is the difference between
770 {option}`life_bytes` and {option}`rekey_bytes`.
771 '';
772
773 rekey_packets = mkIntParam 0 ''
774 Number of packets processed before initiating CHILD_SA rekeying. CHILD_SA
775 rekeying refreshes key material, optionally using a Diffie-Hellman
776 exchange if a group is specified in the proposal.
777
778 To avoid rekey collisions initiated by both ends simultaneously, a value
779 in the range of {option}`rand_packets` gets subtracted to form
780 the effective soft packet count limit.
781
782 Packet count based CHILD_SA rekeying is disabled by default.
783 '';
784
785 life_packets = mkOptionalIntParam ''
786 Maximum number of packets processed before CHILD_SA gets closed. Usually
787 this hard packets limit is never reached, because the CHILD_SA gets
788 rekeyed before. If that fails for whatever reason, this limit closes the
789 CHILD_SA.
790
791 The default is 10% more than {option}`rekey_bytes`.
792 '';
793
794 rand_packets = mkOptionalIntParam ''
795 Packet range from which to choose a random value to subtract from
796 {option}`rekey_packets`. The default is the difference between
797 {option}`life_packets` and {option}`rekey_packets`.
798 '';
799
800 updown = mkOptionalStrParam ''
801 Updown script to invoke on CHILD_SA up and down events.
802 '';
803
804 hostaccess = mkYesNoParam no ''
805 Hostaccess variable to pass to `updown` script.
806 '';
807
808 mode = mkEnumParam [ "tunnel"
809 "transport"
810 "transport_proxy"
811 "beet"
812 "pass"
813 "drop"
814 ] "tunnel" ''
815 IPsec Mode to establish CHILD_SA with.
816
817 - `tunnel` negotiates the CHILD_SA in IPsec Tunnel Mode,
818 - whereas `transport` uses IPsec Transport Mode.
819 - `transport_proxy` signifying the special Mobile IPv6
820 Transport Proxy Mode.
821 - `beet` is the Bound End to End Tunnel mixture mode,
822 working with fixed inner addresses without the need to include them in
823 each packet.
824 - Both `transport` and `beet` modes are
825 subject to mode negotiation; `tunnel` mode is
826 negotiated if the preferred mode is not available.
827 - `pass` and `drop` are used to install
828 shunt policies which explicitly bypass the defined traffic from IPsec
829 processing or drop it, respectively.
830 '';
831
832 policies = mkYesNoParam yes ''
833 Whether to install IPsec policies or not. Disabling this can be useful in
834 some scenarios e.g. MIPv6, where policies are not managed by the IKE
835 daemon. Since 5.3.3.
836 '';
837
838 policies_fwd_out = mkYesNoParam no ''
839 Whether to install outbound FWD IPsec policies or not. Enabling this is
840 required in case there is a drop policy that would match and block
841 forwarded traffic for this CHILD_SA. Since 5.5.1.
842 '';
843
844 dpd_action = mkEnumParam ["clear" "trap" "restart"] "clear" ''
845 Action to perform for this CHILD_SA on DPD timeout. The default clear
846 closes the CHILD_SA and does not take further action. trap installs a
847 trap policy, which will catch matching traffic and tries to re-negotiate
848 the tunnel on-demand. restart immediately tries to re-negotiate the
849 CHILD_SA under a fresh IKE_SA.
850 '';
851
852 ipcomp = mkYesNoParam no ''
853 Enable IPComp compression before encryption. If enabled, IKE tries to
854 negotiate IPComp compression to compress ESP payload data prior to
855 encryption.
856 '';
857
858 inactivity = mkDurationParam "0s" ''
859 Timeout before closing CHILD_SA after inactivity. If no traffic has been
860 processed in either direction for the configured timeout, the CHILD_SA
861 gets closed due to inactivity. The default value of 0 disables inactivity
862 checks.
863 '';
864
865 reqid = mkIntParam 0 ''
866 Fixed reqid to use for this CHILD_SA. This might be helpful in some
867 scenarios, but works only if each CHILD_SA configuration is instantiated
868 not more than once. The default of 0 uses dynamic reqids, allocated
869 incrementally.
870 '';
871
872 priority = mkIntParam 0 ''
873 Optional fixed priority for IPsec policies. This could be useful to
874 install high-priority drop policies. The default of 0 uses dynamically
875 calculated priorities based on the size of the traffic selectors.
876 '';
877
878 interface = mkOptionalStrParam ''
879 Optional interface name to restrict outbound IPsec policies.
880 '';
881
882 mark_in = mkStrParam "0/0x00000000" ''
883 Netfilter mark and mask for input traffic. On Linux, Netfilter may
884 require marks on each packet to match an SA/policy having that option
885 set. This allows installing duplicate policies and enables Netfilter
886 rules to select specific SAs/policies for incoming traffic. Note that
887 inbound marks are only set on policies, by default, unless
888 {option}`mark_in_sa` is enabled. The special value
889 `%unique` sets a unique mark on each CHILD_SA instance,
890 beyond that the value `%unique-dir` assigns a different
891 unique mark for each
892
893 An additional mask may be appended to the mark, separated by
894 `/`. The default mask if omitted is
895 `0xffffffff`.
896 '';
897
898 mark_in_sa = mkYesNoParam no ''
899 Whether to set {option}`mark_in` on the inbound SA. By default,
900 the inbound mark is only set on the inbound policy. The tuple destination
901 address, protocol and SPI is unique and the mark is not required to find
902 the correct SA, allowing to mark traffic after decryption instead (where
903 more specific selectors may be used) to match different policies. Marking
904 packets before decryption is still possible, even if no mark is set on
905 the SA.
906 '';
907
908 mark_out = mkStrParam "0/0x00000000" ''
909 Netfilter mark and mask for output traffic. On Linux, Netfilter may
910 require marks on each packet to match a policy/SA having that option
911 set. This allows installing duplicate policies and enables Netfilter
912 rules to select specific policies/SAs for outgoing traffic. The special
913 value `%unique` sets a unique mark on each CHILD_SA
914 instance, beyond that the value `%unique-dir` assigns a
915 different unique mark for each CHILD_SA direction (in/out).
916
917 An additional mask may be appended to the mark, separated by
918 `/`. The default mask if omitted is
919 `0xffffffff`.
920 '';
921
922 set_mark_in = mkStrParam "0/0x00000000" ''
923 Netfilter mark applied to packets after the inbound IPsec SA processed
924 them. This way it's not necessary to mark packets via Netfilter before
925 decryption or right afterwards to match policies or process them
926 differently (e.g. via policy routing).
927
928 An additional mask may be appended to the mark, separated by
929 `/`. The default mask if omitted is 0xffffffff. The
930 special value `%same` uses the value (but not the mask)
931 from {option}`mark_in` as mark value, which can be fixed,
932 `%unique` or `%unique-dir`.
933
934 Setting marks in XFRM input requires Linux 4.19 or higher.
935 '';
936
937 set_mark_out = mkStrParam "0/0x00000000" ''
938 Netfilter mark applied to packets after the outbound IPsec SA processed
939 them. This allows processing ESP packets differently than the original
940 traffic (e.g. via policy routing).
941
942 An additional mask may be appended to the mark, separated by
943 `/`. The default mask if omitted is 0xffffffff. The
944 special value `%same` uses the value (but not the mask)
945 from {option}`mark_out` as mark value, which can be fixed,
946 `%unique_` or `%unique-dir`.
947
948 Setting marks in XFRM output is supported since Linux 4.14. Setting a
949 mask requires at least Linux 4.19.
950 '';
951
952 if_id_in = mkStrParam "0" ''
953 XFRM interface ID set on inbound policies/SA. This allows installing
954 duplicate policies/SAs and associates them with an interface with the
955 same ID. The special value `%unique` sets a unique
956 interface ID on each CHILD_SA instance, beyond that the value
957 `%unique-dir` assigns a different unique interface ID
958 for each CHILD_SA direction (in/out).
959 '';
960
961 if_id_out = mkStrParam "0" ''
962 XFRM interface ID set on outbound policies/SA. This allows installing
963 duplicate policies/SAs and associates them with an interface with the
964 same ID. The special value `%unique` sets a unique
965 interface ID on each CHILD_SA instance, beyond that the value
966 `%unique-dir` assigns a different unique interface ID
967 for each CHILD_SA direction (in/out).
968
969 The daemon will not install routes for CHILD_SAs that have this option set.
970 '';
971
972 tfc_padding = mkParamOfType (with lib.types; either int (enum ["mtu"])) 0 ''
973 Pads ESP packets with additional data to have a consistent ESP packet
974 size for improved Traffic Flow Confidentiality. The padding defines the
975 minimum size of all ESP packets sent. The default value of
976 `0` disables TFC padding, the special value
977 `mtu` adds TFC padding to create a packet size equal to
978 the Path Maximum Transfer Unit.
979 '';
980
981 replay_window = mkIntParam 32 ''
982 IPsec replay window to configure for this CHILD_SA. Larger values than
983 the default of `32` are supported using the Netlink
984 backend only, a value of `0` disables IPsec replay
985 protection.
986 '';
987
988 hw_offload = mkEnumParam ["yes" "no" "auto"] "no" ''
989 Enable hardware offload for this CHILD_SA, if supported by the IPsec
990 implementation. The value `yes` enforces offloading
991 and the installation will fail if it's not supported by either kernel or
992 device. The value `auto` enables offloading, if it's
993 supported, but the installation does not fail otherwise.
994 '';
995
996 copy_df = mkYesNoParam yes ''
997 Whether to copy the DF bit to the outer IPv4 header in tunnel mode. This
998 effectively disables Path MTU discovery (PMTUD). Controlling this
999 behavior is not supported by all kernel interfaces.
1000 '';
1001
1002 copy_ecn = mkYesNoParam yes ''
1003 Whether to copy the ECN (Explicit Congestion Notification) header field
1004 to/from the outer IP header in tunnel mode. Controlling this behavior is
1005 not supported by all kernel interfaces.
1006 '';
1007
1008 copy_dscp = mkEnumParam [ "out" "in" "yes" "no" ] "out" ''
1009 Whether to copy the DSCP (Differentiated Services Field Codepoint)
1010 header field to/from the outer IP header in tunnel mode. The value
1011 `out` only copies the field from the inner to the outer
1012 header, the value `in` does the opposite and only
1013 copies the field from the outer to the inner header when decapsulating,
1014 the value `yes` copies the field in both directions,
1015 and the value `no` disables copying the field
1016 altogether. Setting this to `yes` or
1017 `in` could allow an attacker to adversely affect other
1018 traffic at the receiver, which is why the default is
1019 `out`. Controlling this behavior is not supported by
1020 all kernel interfaces.
1021 '';
1022
1023 start_action = mkEnumParam ["none" "trap" "start"] "none" ''
1024 Action to perform after loading the configuration.
1025
1026 - The default of `none` loads the connection only, which
1027 then can be manually initiated or used as a responder configuration.
1028 - The value `trap` installs a trap policy, which triggers
1029 the tunnel as soon as matching traffic has been detected.
1030 - The value `start` initiates the connection actively.
1031
1032 When unloading or replacing a CHILD_SA configuration having a
1033 {option}`start_action` different from `none`,
1034 the inverse action is performed. Configurations with
1035 `start` get closed, while such with
1036 `trap` get uninstalled.
1037 '';
1038
1039 close_action = mkEnumParam ["none" "trap" "start"] "none" ''
1040 Action to perform after a CHILD_SA gets closed by the peer.
1041
1042 - The default of `none` does not take any action,
1043 - `trap` installs a trap policy for the CHILD_SA.
1044 - `start` tries to re-create the CHILD_SA.
1045
1046 {option}`close_action` does not provide any guarantee that the
1047 CHILD_SA is kept alive. It acts on explicit close messages only, but not
1048 on negotiation failures. Use trap policies to reliably re-create failed
1049 CHILD_SAs.
1050 '';
1051
1052 } ''
1053 CHILD_SA configuration sub-section. Each connection definition may have
1054 one or more sections in its {option}`children` subsection. The
1055 section name defines the name of the CHILD_SA configuration, which must be
1056 unique within the connection (denoted \<child\> below).
1057 '';
1058 } ''
1059 Section defining IKE connection configurations, each in its own subsection
1060 with an arbitrary yet unique name
1061 '';
1062
1063 secrets = let
1064 mkEapXauthParams = mkPrefixedAttrsOfParams {
1065 secret = mkOptionalStrParam ''
1066 Value of the EAP/XAuth secret. It may either be an ASCII string, a hex
1067 encoded string if it has a 0x prefix or a Base64 encoded string if it
1068 has a 0s prefix in its value.
1069 '';
1070
1071 id = mkPrefixedAttrsOfParam (mkOptionalStrParam "") ''
1072 Identity the EAP/XAuth secret belongs to. Multiple unique identities may
1073 be specified, each having an `id` prefix, if a secret
1074 is shared between multiple users.
1075 '';
1076
1077 } ''
1078 EAP secret section for a specific secret. Each EAP secret is defined in a
1079 unique section having the `eap` prefix. EAP secrets are
1080 used for XAuth authentication as well.
1081 '';
1082
1083 in {
1084
1085 eap = mkEapXauthParams;
1086 xauth = mkEapXauthParams;
1087
1088 ntlm = mkPrefixedAttrsOfParams {
1089 secret = mkOptionalStrParam ''
1090 Value of the NTLM secret, which is the NT Hash of the actual secret,
1091 that is, MD4(UTF-16LE(secret)). The resulting 16-byte value may either
1092 be given as a hex encoded string with a 0x prefix or as a Base64 encoded
1093 string with a 0s prefix.
1094 '';
1095
1096 id = mkPrefixedAttrsOfParam (mkOptionalStrParam "") ''
1097 Identity the NTLM secret belongs to. Multiple unique identities may be
1098 specified, each having an id prefix, if a secret is shared between
1099 multiple users.
1100 '';
1101 } ''
1102 NTLM secret section for a specific secret. Each NTLM secret is defined in
1103 a unique section having the `ntlm` prefix. NTLM secrets
1104 may only be used for EAP-MSCHAPv2 authentication.
1105 '';
1106
1107 ike = mkPrefixedAttrsOfParams {
1108 secret = mkOptionalStrParam ''
1109 Value of the IKE preshared secret. It may either be an ASCII string, a
1110 hex encoded string if it has a 0x prefix or a Base64 encoded string if
1111 it has a 0s prefix in its value.
1112 '';
1113
1114 id = mkPrefixedAttrsOfParam (mkOptionalStrParam "") ''
1115 IKE identity the IKE preshared secret belongs to. Multiple unique
1116 identities may be specified, each having an `id`
1117 prefix, if a secret is shared between multiple peers.
1118 '';
1119 } ''
1120 IKE preshared secret section for a specific secret. Each IKE PSK is
1121 defined in a unique section having the `ike` prefix.
1122 '';
1123
1124 ppk = mkPrefixedAttrsOfParams {
1125 secret = mkOptionalStrParam ''
1126 Value of the PPK. It may either be an ASCII string, a hex encoded string
1127 if it has a `0x` prefix or a Base64 encoded string if
1128 it has a `0s` prefix in its value. Should have at least
1129 256 bits of entropy for 128-bit security.
1130 '';
1131
1132 id = mkPrefixedAttrsOfParam (mkOptionalStrParam "") ''
1133 PPK identity the PPK belongs to. Multiple unique identities may be
1134 specified, each having an `id` prefix, if a secret is
1135 shared between multiple peers.
1136 '';
1137 } ''
1138 Postquantum Preshared Key (PPK) section for a specific secret. Each PPK is
1139 defined in a unique section having the `ppk` prefix.
1140 '';
1141
1142 private = mkPrefixedAttrsOfParams {
1143 file = mkOptionalStrParam ''
1144 File name in the private folder for which this passphrase should be used.
1145 '';
1146
1147 secret = mkOptionalStrParam ''
1148 Value of decryption passphrase for private key.
1149 '';
1150 } ''
1151 Private key decryption passphrase for a key in the
1152 `private` folder.
1153 '';
1154
1155 rsa = mkPrefixedAttrsOfParams {
1156 file = mkOptionalStrParam ''
1157 File name in the `rsa` folder for which this passphrase
1158 should be used.
1159 '';
1160 secret = mkOptionalStrParam ''
1161 Value of decryption passphrase for RSA key.
1162 '';
1163 } ''
1164 Private key decryption passphrase for a key in the `rsa`
1165 folder.
1166 '';
1167
1168 ecdsa = mkPrefixedAttrsOfParams {
1169 file = mkOptionalStrParam ''
1170 File name in the `ecdsa` folder for which this
1171 passphrase should be used.
1172 '';
1173 secret = mkOptionalStrParam ''
1174 Value of decryption passphrase for ECDSA key.
1175 '';
1176 } ''
1177 Private key decryption passphrase for a key in the
1178 `ecdsa` folder.
1179 '';
1180
1181 pkcs8 = mkPrefixedAttrsOfParams {
1182 file = mkOptionalStrParam ''
1183 File name in the `pkcs8` folder for which this
1184 passphrase should be used.
1185 '';
1186 secret = mkOptionalStrParam ''
1187 Value of decryption passphrase for PKCS#8 key.
1188 '';
1189 } ''
1190 Private key decryption passphrase for a key in the
1191 `pkcs8` folder.
1192 '';
1193
1194 pkcs12 = mkPrefixedAttrsOfParams {
1195 file = mkOptionalStrParam ''
1196 File name in the `pkcs12` folder for which this
1197 passphrase should be used.
1198 '';
1199 secret = mkOptionalStrParam ''
1200 Value of decryption passphrase for PKCS#12 container.
1201 '';
1202 } ''
1203 PKCS#12 decryption passphrase for a container in the
1204 `pkcs12` folder.
1205 '';
1206
1207 token = mkPrefixedAttrsOfParams {
1208 handle = mkOptionalHexParam ''
1209 Hex-encoded CKA_ID or handle of the private key on the token or TPM,
1210 respectively.
1211 '';
1212
1213 slot = mkOptionalIntParam ''
1214 Optional slot number to access the token.
1215 '';
1216
1217 module = mkOptionalStrParam ''
1218 Optional PKCS#11 module name to access the token.
1219 '';
1220
1221 pin = mkOptionalStrParam ''
1222 Optional PIN required to access the key on the token. If none is
1223 provided the user is prompted during an interactive
1224 `--load-creds` call.
1225 '';
1226 } "Definition for a private key that's stored on a token/smartcard/TPM.";
1227
1228 };
1229
1230 pools = mkAttrsOfParams {
1231 addrs = mkOptionalStrParam ''
1232 Subnet or range defining addresses allocated in pool. Accepts a single
1233 CIDR subnet defining the pool to allocate addresses from or an address
1234 range (\<from\>-\<to\>). Pools must be unique and non-overlapping.
1235 '';
1236
1237 dns = mkCommaSepListParam [] "Address or CIDR subnets";
1238 nbns = mkCommaSepListParam [] "Address or CIDR subnets";
1239 dhcp = mkCommaSepListParam [] "Address or CIDR subnets";
1240 netmask = mkCommaSepListParam [] "Address or CIDR subnets";
1241 server = mkCommaSepListParam [] "Address or CIDR subnets";
1242 subnet = mkCommaSepListParam [] "Address or CIDR subnets";
1243 split_include = mkCommaSepListParam [] "Address or CIDR subnets";
1244 split_exclude = mkCommaSepListParam [] "Address or CIDR subnets";
1245 } ''
1246 Section defining named pools. Named pools may be referenced by connections
1247 with the pools option to assign virtual IPs and other configuration
1248 attributes. Each pool must have a unique name (denoted \<name\> below).
1249 '';
1250}