Debian Codegraph @

src/interfaces/libpq/fe-secure-gssapi.c

raw
1 /*-------------------------------------------------------------------------
2 *
3 * fe-secure-gssapi.c
4 * The front-end (client) encryption support for GSSAPI
5 *
6 * Portions Copyright (c) 2016-2025, PostgreSQL Global Development Group
7 *
8 * IDENTIFICATION
9 * src/interfaces/libpq/fe-secure-gssapi.c
10 *
11 *-------------------------------------------------------------------------
12 */
13
14 #include "postgres_fe.h"
15
16 #include "fe-gssapi-common.h"
17 #include "libpq-fe.h"
18 #include "libpq-int.h"
19 #include "port/pg_bswap.h"
20
21
22 /*
23 * Require encryption support, as well as mutual authentication and
24 * tamperproofing measures.
25 */
26 #define GSS_REQUIRED_FLAGS GSS_C_MUTUAL_FLAG | GSS_C_REPLAY_FLAG | \
27 GSS_C_SEQUENCE_FLAG | GSS_C_CONF_FLAG | GSS_C_INTEG_FLAG
28
29 /*
30 * Handle the encryption/decryption of data using GSSAPI.
31 *
32 * In the encrypted data stream on the wire, we break up the data
33 * into packets where each packet starts with a uint32-size length
34 * word (in network byte order), then encrypted data of that length
35 * immediately following. Decryption yields the same data stream
36 * that would appear when not using encryption.
37 *
38 * Encrypted data typically ends up being larger than the same data
39 * unencrypted, so we use fixed-size buffers for handling the
40 * encryption/decryption which are larger than PQComm's buffer will
41 * typically be to minimize the times where we have to make multiple
42 * packets (and therefore multiple recv/send calls for a single
43 * read/write call to us).
44 *
45 * NOTE: The client and server have to agree on the max packet size,
46 * because we have to pass an entire packet to GSSAPI at a time and we
47 * don't want the other side to send arbitrarily huge packets as we
48 * would have to allocate memory for them to then pass them to GSSAPI.
49 *
50 * Therefore, this #define is effectively part of the protocol
51 * spec and can't ever be changed.
52 */
53 #define PQ_GSS_MAX_PACKET_SIZE 16384 /* includes uint32 header word */
54
55 /*
56 * However, during the authentication exchange we must cope with whatever
57 * message size the GSSAPI library wants to send (because our protocol
58 * doesn't support splitting those messages). Depending on configuration
59 * those messages might be as much as 64kB.
60 */
61 #define PQ_GSS_AUTH_BUFFER_SIZE 65536 /* includes uint32 header word */
62
63 /*
64 * We need these state variables per-connection. To allow the functions
65 * in this file to look mostly like those in be-secure-gssapi.c, set up
66 * these macros.
67 */
68 #define PqGSSSendBuffer (conn->gss_SendBuffer)
69 #define PqGSSSendLength (conn->gss_SendLength)
70 #define PqGSSSendNext (conn->gss_SendNext)
71 #define PqGSSSendConsumed (conn->gss_SendConsumed)
72 #define PqGSSRecvBuffer (conn->gss_RecvBuffer)
73 #define PqGSSRecvLength (conn->gss_RecvLength)
74 #define PqGSSResultBuffer (conn->gss_ResultBuffer)
75 #define PqGSSResultLength (conn->gss_ResultLength)
76 #define PqGSSResultNext (conn->gss_ResultNext)
77 #define PqGSSMaxPktSize (conn->gss_MaxPktSize)
78
79
80 /*
81 * Attempt to write len bytes of data from ptr to a GSSAPI-encrypted connection.
82 *
83 * The connection must be already set up for GSSAPI encryption (i.e., GSSAPI
84 * transport negotiation is complete).
85 *
86 * On success, returns the number of data bytes consumed (possibly less than
87 * len). On failure, returns -1 with errno set appropriately. If the errno
88 * indicates a non-retryable error, a message is added to conn->errorMessage.
89 * For retryable errors, caller should call again (passing the same or more
90 * data) once the socket is ready.
91 */
92 ssize_t
93 pg_GSS_write(PGconn *conn, const void *ptr, size_t len)
94 {
95 OM_uint32 major,
96 minor;
97 gss_buffer_desc input,
98 output = GSS_C_EMPTY_BUFFER;
99 ssize_t ret = -1;
100 size_t bytes_to_encrypt;
101 size_t bytes_encrypted;
102 gss_ctx_id_t gctx = conn->gctx;
103
104 /*
105 * When we get a retryable failure, we must not tell the caller we have
106 * successfully transmitted everything, else it won't retry. For
107 * simplicity, we claim we haven't transmitted anything until we have
108 * successfully transmitted all "len" bytes. Between calls, the amount of
109 * the current input data that's already been encrypted and placed into
110 * PqGSSSendBuffer (and perhaps transmitted) is remembered in
111 * PqGSSSendConsumed. On a retry, the caller *must* be sending that data
112 * again, so if it offers a len less than that, something is wrong.
113 *
114 * Note: it may seem attractive to report partial write completion once
115 * we've successfully sent any encrypted packets. However, doing that
116 * expands the state space of this processing and has been responsible for
117 * bugs in the past (cf. commit d053a879b). We won't save much,
118 * typically, by letting callers discard data early, so don't risk it.
119 */
120 if (len < PqGSSSendConsumed)
121 {
122 appendPQExpBufferStr(&conn->errorMessage,
123 "GSSAPI caller failed to retransmit all data needing to be retried\n");
124 SOCK_ERRNO_SET(EINVAL);
125 return -1;
126 }
127
128 /* Discount whatever source data we already encrypted. */
129 bytes_to_encrypt = len - PqGSSSendConsumed;
130 bytes_encrypted = PqGSSSendConsumed;
131
132 /*
133 * Loop through encrypting data and sending it out until it's all done or
134 * pqsecure_raw_write() complains (which would likely mean that the socket
135 * is non-blocking and the requested send() would block, or there was some
136 * kind of actual error).
137 */
138 while (bytes_to_encrypt || PqGSSSendLength)
139 {
140 int conf_state = 0;
141 uint32 netlen;
142
143 /*
144 * Check if we have data in the encrypted output buffer that needs to
145 * be sent (possibly left over from a previous call), and if so, try
146 * to send it. If we aren't able to, return that fact back up to the
147 * caller.
148 */
149 if (PqGSSSendLength)
150 {
151 ssize_t retval;
152 ssize_t amount = PqGSSSendLength - PqGSSSendNext;
153
154 retval = pqsecure_raw_write(conn, PqGSSSendBuffer + PqGSSSendNext, amount);
155 if (retval <= 0)
156 return retval;
157
158 /*
159 * Check if this was a partial write, and if so, move forward that
160 * far in our buffer and try again.
161 */
162 if (retval < amount)
163 {
164 PqGSSSendNext += retval;
165 continue;
166 }
167
168 /* We've successfully sent whatever data was in the buffer. */
169 PqGSSSendLength = PqGSSSendNext = 0;
170 }
171
172 /*
173 * Check if there are any bytes left to encrypt. If not, we're done.
174 */
175 if (!bytes_to_encrypt)
176 break;
177
178 /*
179 * Check how much we are being asked to send, if it's too much, then
180 * we will have to loop and possibly be called multiple times to get
181 * through all the data.
182 */
183 if (bytes_to_encrypt > PqGSSMaxPktSize)
184 input.length = PqGSSMaxPktSize;
185 else
186 input.length = bytes_to_encrypt;
187
188 input.value = (char *) ptr + bytes_encrypted;
189
190 output.value = NULL;
191 output.length = 0;
192
193 /*
194 * Create the next encrypted packet. Any failure here is considered a
195 * hard failure, so we return -1 even if some data has been sent.
196 */
197 major = gss_wrap(&minor, gctx, 1, GSS_C_QOP_DEFAULT,
198 &input, &conf_state, &output);
199 if (major != GSS_S_COMPLETE)
200 {
201 pg_GSS_error(libpq_gettext("GSSAPI wrap error"), conn, major, minor);
202 SOCK_ERRNO_SET(EIO); /* for lack of a better idea */
203 goto cleanup;
204 }
205
206 if (conf_state == 0)
207 {
208 libpq_append_conn_error(conn, "outgoing GSSAPI message would not use confidentiality");
209 SOCK_ERRNO_SET(EIO); /* for lack of a better idea */
210 goto cleanup;
211 }
212
213 if (output.length > PQ_GSS_MAX_PACKET_SIZE - sizeof(uint32))
214 {
215 libpq_append_conn_error(conn, "client tried to send oversize GSSAPI packet (%zu > %zu)",
216 (size_t) output.length,
217 PQ_GSS_MAX_PACKET_SIZE - sizeof(uint32));
218 SOCK_ERRNO_SET(EIO); /* for lack of a better idea */
219 goto cleanup;
220 }
221
222 bytes_encrypted += input.length;
223 bytes_to_encrypt -= input.length;
224 PqGSSSendConsumed += input.length;
225
226 /* 4 network-order bytes of length, then payload */
227 netlen = pg_hton32(output.length);
228 memcpy(PqGSSSendBuffer + PqGSSSendLength, &netlen, sizeof(uint32));
229 PqGSSSendLength += sizeof(uint32);
230
231 memcpy(PqGSSSendBuffer + PqGSSSendLength, output.value, output.length);
232 PqGSSSendLength += output.length;
233
234 /* Release buffer storage allocated by GSSAPI */
235 gss_release_buffer(&minor, &output);
236 }
237
238 /* If we get here, our counters should all match up. */
239 Assert(len == PqGSSSendConsumed);
240 Assert(len == bytes_encrypted);
241
242 /* We're reporting all the data as sent, so reset PqGSSSendConsumed. */
243 PqGSSSendConsumed = 0;
244
245 ret = bytes_encrypted;
246
247 cleanup:
248 /* Release GSSAPI buffer storage, if we didn't already */
249 if (output.value != NULL)
250 gss_release_buffer(&minor, &output);
251 return ret;
252 }
253
254 /*
255 * Read up to len bytes of data into ptr from a GSSAPI-encrypted connection.
256 *
257 * The connection must be already set up for GSSAPI encryption (i.e., GSSAPI
258 * transport negotiation is complete).
259 *
260 * Returns the number of data bytes read, or on failure, returns -1
261 * with errno set appropriately. If the errno indicates a non-retryable
262 * error, a message is added to conn->errorMessage. For retryable errors,
263 * caller should call again once the socket is ready.
264 */
265 ssize_t
266 pg_GSS_read(PGconn *conn, void *ptr, size_t len)
267 {
268 OM_uint32 major,
269 minor;
270 gss_buffer_desc input = GSS_C_EMPTY_BUFFER,
271 output = GSS_C_EMPTY_BUFFER;
272 ssize_t ret;
273 size_t bytes_returned = 0;
274 gss_ctx_id_t gctx = conn->gctx;
275
276 /*
277 * The plan here is to read one incoming encrypted packet into
278 * PqGSSRecvBuffer, decrypt it into PqGSSResultBuffer, and then dole out
279 * data from there to the caller. When we exhaust the current input
280 * packet, read another.
281 */
282 while (bytes_returned < len)
283 {
284 int conf_state = 0;
285
286 /* Check if we have data in our buffer that we can return immediately */
287 if (PqGSSResultNext < PqGSSResultLength)
288 {
289 size_t bytes_in_buffer = PqGSSResultLength - PqGSSResultNext;
290 size_t bytes_to_copy = Min(bytes_in_buffer, len - bytes_returned);
291
292 /*
293 * Copy the data from our result buffer into the caller's buffer,
294 * at the point where we last left off filling their buffer.
295 */
296 memcpy((char *) ptr + bytes_returned, PqGSSResultBuffer + PqGSSResultNext, bytes_to_copy);
297 PqGSSResultNext += bytes_to_copy;
298 bytes_returned += bytes_to_copy;
299
300 /*
301 * At this point, we've either filled the caller's buffer or
302 * emptied our result buffer. Either way, return to caller. In
303 * the second case, we could try to read another encrypted packet,
304 * but the odds are good that there isn't one available. (If this
305 * isn't true, we chose too small a max packet size.) In any
306 * case, there's no harm letting the caller process the data we've
307 * already returned.
308 */
309 break;
310 }
311
312 /* Result buffer is empty, so reset buffer pointers */
313 PqGSSResultLength = PqGSSResultNext = 0;
314
315 /*
316 * Because we chose above to return immediately as soon as we emit
317 * some data, bytes_returned must be zero at this point. Therefore
318 * the failure exits below can just return -1 without worrying about
319 * whether we already emitted some data.
320 */
321 Assert(bytes_returned == 0);
322
323 /*
324 * At this point, our result buffer is empty with more bytes being
325 * requested to be read. We are now ready to load the next packet and
326 * decrypt it (entirely) into our result buffer.
327 */
328
329 /* Collect the length if we haven't already */
330 if (PqGSSRecvLength < sizeof(uint32))
331 {
332 ret = pqsecure_raw_read(conn, PqGSSRecvBuffer + PqGSSRecvLength,
333 sizeof(uint32) - PqGSSRecvLength);
334
335 /* If ret <= 0, pqsecure_raw_read already set the correct errno */
336 if (ret <= 0)
337 return ret;
338
339 PqGSSRecvLength += ret;
340
341 /* If we still haven't got the length, return to the caller */
342 if (PqGSSRecvLength < sizeof(uint32))
343 {
344 SOCK_ERRNO_SET(EWOULDBLOCK);
345 return -1;
346 }
347 }
348
349 /* Decode the packet length and check for overlength packet */
350 input.length = pg_ntoh32(*(uint32 *) PqGSSRecvBuffer);
351
352 if (input.length > PQ_GSS_MAX_PACKET_SIZE - sizeof(uint32))
353 {
354 libpq_append_conn_error(conn, "oversize GSSAPI packet sent by the server (%zu > %zu)",
355 (size_t) input.length,
356 PQ_GSS_MAX_PACKET_SIZE - sizeof(uint32));
357 SOCK_ERRNO_SET(EIO); /* for lack of a better idea */
358 return -1;
359 }
360
361 /*
362 * Read as much of the packet as we are able to on this call into
363 * wherever we left off from the last time we were called.
364 */
365 ret = pqsecure_raw_read(conn, PqGSSRecvBuffer + PqGSSRecvLength,
366 input.length - (PqGSSRecvLength - sizeof(uint32)));
367 /* If ret <= 0, pqsecure_raw_read already set the correct errno */
368 if (ret <= 0)
369 return ret;
370
371 PqGSSRecvLength += ret;
372
373 /* If we don't yet have the whole packet, return to the caller */
374 if (PqGSSRecvLength - sizeof(uint32) < input.length)
375 {
376 SOCK_ERRNO_SET(EWOULDBLOCK);
377 return -1;
378 }
379
380 /*
381 * We now have the full packet and we can perform the decryption and
382 * refill our result buffer, then loop back up to pass data back to
383 * the caller. Note that error exits below here must take care of
384 * releasing the gss output buffer.
385 */
386 output.value = NULL;
387 output.length = 0;
388 input.value = PqGSSRecvBuffer + sizeof(uint32);
389
390 major = gss_unwrap(&minor, gctx, &input, &output, &conf_state, NULL);
391 if (major != GSS_S_COMPLETE)
392 {
393 pg_GSS_error(libpq_gettext("GSSAPI unwrap error"), conn,
394 major, minor);
395 ret = -1;
396 SOCK_ERRNO_SET(EIO); /* for lack of a better idea */
397 goto cleanup;
398 }
399
400 if (conf_state == 0)
401 {
402 libpq_append_conn_error(conn, "incoming GSSAPI message did not use confidentiality");
403 ret = -1;
404 SOCK_ERRNO_SET(EIO); /* for lack of a better idea */
405 goto cleanup;
406 }
407
408 memcpy(PqGSSResultBuffer, output.value, output.length);
409 PqGSSResultLength = output.length;
410
411 /* Our receive buffer is now empty, reset it */
412 PqGSSRecvLength = 0;
413
414 /* Release buffer storage allocated by GSSAPI */
415 gss_release_buffer(&minor, &output);
416 }
417
418 ret = bytes_returned;
419
420 cleanup:
421 /* Release GSSAPI buffer storage, if we didn't already */
422 if (output.value != NULL)
423 gss_release_buffer(&minor, &output);
424 return ret;
425 }
426
427 /*
428 * Simple wrapper for reading from pqsecure_raw_read.
429 *
430 * This takes the same arguments as pqsecure_raw_read, plus an output parameter
431 * to return the number of bytes read. This handles if blocking would occur and
432 * if we detect EOF on the connection.
433 */
434 static PostgresPollingStatusType
435 gss_read(PGconn *conn, void *recv_buffer, size_t length, ssize_t *ret)
436 {
437 *ret = pqsecure_raw_read(conn, recv_buffer, length);
438 if (*ret < 0)
439 {
440 if (SOCK_ERRNO == EAGAIN || SOCK_ERRNO == EWOULDBLOCK ||
441 SOCK_ERRNO == EINTR)
442 return PGRES_POLLING_READING;
443 else
444 return PGRES_POLLING_FAILED;
445 }
446
447 /* Check for EOF */
448 if (*ret == 0)
449 {
450 int result = pqReadReady(conn);
451
452 if (result < 0)
453 return PGRES_POLLING_FAILED;
454
455 if (!result)
456 return PGRES_POLLING_READING;
457
458 *ret = pqsecure_raw_read(conn, recv_buffer, length);
459 if (*ret < 0)
460 {
461 if (SOCK_ERRNO == EAGAIN || SOCK_ERRNO == EWOULDBLOCK ||
462 SOCK_ERRNO == EINTR)
463 return PGRES_POLLING_READING;
464 else
465 return PGRES_POLLING_FAILED;
466 }
467 if (*ret == 0)
468 return PGRES_POLLING_FAILED;
469 }
470
471 return PGRES_POLLING_OK;
472 }
473
474 ssize_t
475 pg_GSS_bytes_pending(PGconn *conn)
476 {
477 Assert(PqGSSResultLength >= PqGSSResultNext);
478 return (ssize_t) (PqGSSResultLength - PqGSSResultNext);
479 }
480
481 /*
482 * Negotiate GSSAPI transport for a connection. When complete, returns
483 * PGRES_POLLING_OK. Will return PGRES_POLLING_READING or
484 * PGRES_POLLING_WRITING as appropriate whenever it would block, and
485 * PGRES_POLLING_FAILED if transport could not be negotiated.
486 */
487 PostgresPollingStatusType
488 pqsecure_open_gss(PGconn *conn)
489 {
490 ssize_t ret;
491 OM_uint32 major,
492 minor,
493 gss_flags = GSS_REQUIRED_FLAGS;
494 uint32 netlen;
495 PostgresPollingStatusType result;
496 gss_buffer_desc input = GSS_C_EMPTY_BUFFER,
497 output = GSS_C_EMPTY_BUFFER;
498
499 /*
500 * If first time through for this connection, allocate buffers and
501 * initialize state variables. By malloc'ing the buffers separately, we
502 * ensure that they are sufficiently aligned for the length-word accesses
503 * that we do in some places in this file.
504 *
505 * We'll use PQ_GSS_AUTH_BUFFER_SIZE-sized buffers until transport
506 * negotiation is complete, then switch to PQ_GSS_MAX_PACKET_SIZE.
507 */
508 if (PqGSSSendBuffer == NULL)
509 {
510 PqGSSSendBuffer = malloc(PQ_GSS_AUTH_BUFFER_SIZE);
511 PqGSSRecvBuffer = malloc(PQ_GSS_AUTH_BUFFER_SIZE);
512 PqGSSResultBuffer = malloc(PQ_GSS_AUTH_BUFFER_SIZE);
513 if (!PqGSSSendBuffer || !PqGSSRecvBuffer || !PqGSSResultBuffer)
514 {
515 libpq_append_conn_error(conn, "out of memory");
516 return PGRES_POLLING_FAILED;
517 }
518 PqGSSSendLength = PqGSSSendNext = PqGSSSendConsumed = 0;
519 PqGSSRecvLength = PqGSSResultLength = PqGSSResultNext = 0;
520 }
521
522 /*
523 * Check if we have anything to send from a prior call and if so, send it.
524 */
525 if (PqGSSSendLength)
526 {
527 ssize_t amount = PqGSSSendLength - PqGSSSendNext;
528
529 ret = pqsecure_raw_write(conn, PqGSSSendBuffer + PqGSSSendNext, amount);
530 if (ret < 0)
531 {
532 if (SOCK_ERRNO == EAGAIN || SOCK_ERRNO == EWOULDBLOCK ||
533 SOCK_ERRNO == EINTR)
534 return PGRES_POLLING_WRITING;
535 else
536 return PGRES_POLLING_FAILED;
537 }
538
539 if (ret < amount)
540 {
541 PqGSSSendNext += ret;
542 return PGRES_POLLING_WRITING;
543 }
544
545 PqGSSSendLength = PqGSSSendNext = 0;
546 }
547
548 /*
549 * Client sends first, and sending creates a context, therefore this will
550 * be false the first time through, and then when we get called again we
551 * will check for incoming data.
552 */
553 if (conn->gctx)
554 {
555 /* Process any incoming data we might have */
556
557 /* See if we are still trying to get the length */
558 if (PqGSSRecvLength < sizeof(uint32))
559 {
560 /* Attempt to get the length first */
561 result = gss_read(conn, PqGSSRecvBuffer + PqGSSRecvLength, sizeof(uint32) - PqGSSRecvLength, &ret);
562 if (result != PGRES_POLLING_OK)
563 return result;
564
565 PqGSSRecvLength += ret;
566
567 if (PqGSSRecvLength < sizeof(uint32))
568 return PGRES_POLLING_READING;
569 }
570
571 /*
572 * Check if we got an error packet
573 *
574 * This is safe to do because we shouldn't ever get a packet over 8192
575 * and therefore the actual length bytes, being that they are in
576 * network byte order, for any real packet will start with two zero
577 * bytes.
578 */
579 if (PqGSSRecvBuffer[0] == 'E')
580 {
581 /*
582 * For an error packet during startup, we don't get a length, so
583 * simply read as much as we can fit into our buffer (as a string,
584 * so leave a spot at the end for a NULL byte too) and report that
585 * back to the caller.
586 */
587 result = gss_read(conn, PqGSSRecvBuffer + PqGSSRecvLength, PQ_GSS_AUTH_BUFFER_SIZE - PqGSSRecvLength - 1, &ret);
588 if (result != PGRES_POLLING_OK)
589 return result;
590
591 PqGSSRecvLength += ret;
592
593 Assert(PqGSSRecvLength < PQ_GSS_AUTH_BUFFER_SIZE);
594 PqGSSRecvBuffer[PqGSSRecvLength] = '\0';
595 appendPQExpBuffer(&conn->errorMessage, "%s\n", PqGSSRecvBuffer + 1);
596
597 return PGRES_POLLING_FAILED;
598 }
599
600 /*
601 * We should have the whole length at this point, so pull it out and
602 * then read whatever we have left of the packet
603 */
604
605 /* Get the length and check for over-length packet */
606 input.length = pg_ntoh32(*(uint32 *) PqGSSRecvBuffer);
607 if (input.length > PQ_GSS_AUTH_BUFFER_SIZE - sizeof(uint32))
608 {
609 libpq_append_conn_error(conn, "oversize GSSAPI packet sent by the server (%zu > %zu)",
610 (size_t) input.length,
611 PQ_GSS_AUTH_BUFFER_SIZE - sizeof(uint32));
612 return PGRES_POLLING_FAILED;
613 }
614
615 /*
616 * Read as much of the packet as we are able to on this call into
617 * wherever we left off from the last time we were called.
618 */
619 result = gss_read(conn, PqGSSRecvBuffer + PqGSSRecvLength,
620 input.length - (PqGSSRecvLength - sizeof(uint32)), &ret);
621 if (result != PGRES_POLLING_OK)
622 return result;
623
624 PqGSSRecvLength += ret;
625
626 /*
627 * If we got less than the rest of the packet then we need to return
628 * and be called again.
629 */
630 if (PqGSSRecvLength - sizeof(uint32) < input.length)
631 return PGRES_POLLING_READING;
632
633 input.value = PqGSSRecvBuffer + sizeof(uint32);
634 }
635
636 /* Load the service name (no-op if already done */
637 ret = pg_GSS_load_servicename(conn);
638 if (ret != STATUS_OK)
639 return PGRES_POLLING_FAILED;
640
641 if (conn->gssdelegation && conn->gssdelegation[0] == '1')
642 {
643 /* Acquire credentials if possible */
644 if (conn->gcred == GSS_C_NO_CREDENTIAL)
645 (void) pg_GSS_have_cred_cache(&conn->gcred);
646
647 /*
648 * We have credentials and gssdelegation is enabled, so request
649 * credential delegation. This may or may not actually result in
650 * credentials being delegated- it depends on if the forwardable flag
651 * has been set in the credential and if the server is configured to
652 * accept delegated credentials.
653 */
654 if (conn->gcred != GSS_C_NO_CREDENTIAL)
655 gss_flags |= GSS_C_DELEG_FLAG;
656 }
657
658 /*
659 * Call GSS init context, either with an empty input, or with a complete
660 * packet from the server.
661 */
662 major = gss_init_sec_context(&minor, conn->gcred, &conn->gctx,
663 conn->gtarg_nam, GSS_C_NO_OID,
664 gss_flags, 0, 0, &input, NULL,
665 &output, NULL, NULL);
666
667 /* GSS Init Sec Context uses the whole packet, so clear it */
668 PqGSSRecvLength = 0;
669
670 if (GSS_ERROR(major))
671 {
672 pg_GSS_error(libpq_gettext("could not initiate GSSAPI security context"),
673 conn, major, minor);
674 return PGRES_POLLING_FAILED;
675 }
676
677 if (output.length == 0)
678 {
679 /*
680 * We're done - hooray! Set flag to tell the low-level I/O routines
681 * to do GSS wrapping/unwrapping.
682 */
683 conn->gssenc = true;
684 conn->gssapi_used = true;
685
686 /* Clean up */
687 gss_release_cred(&minor, &conn->gcred);
688 conn->gcred = GSS_C_NO_CREDENTIAL;
689 gss_release_buffer(&minor, &output);
690
691 /*
692 * Release the large authentication buffers and allocate the ones we
693 * want for normal operation. (This maneuver is safe only because
694 * pqDropConnection will drop the buffers; otherwise, during a
695 * reconnection we'd be at risk of using undersized buffers during
696 * negotiation.)
697 */
698 free(PqGSSSendBuffer);
699 free(PqGSSRecvBuffer);
700 free(PqGSSResultBuffer);
701 PqGSSSendBuffer = malloc(PQ_GSS_MAX_PACKET_SIZE);
702 PqGSSRecvBuffer = malloc(PQ_GSS_MAX_PACKET_SIZE);
703 PqGSSResultBuffer = malloc(PQ_GSS_MAX_PACKET_SIZE);
704 if (!PqGSSSendBuffer || !PqGSSRecvBuffer || !PqGSSResultBuffer)
705 {
706 libpq_append_conn_error(conn, "out of memory");
707 return PGRES_POLLING_FAILED;
708 }
709 PqGSSSendLength = PqGSSSendNext = PqGSSSendConsumed = 0;
710 PqGSSRecvLength = PqGSSResultLength = PqGSSResultNext = 0;
711
712 /*
713 * Determine the max packet size which will fit in our buffer, after
714 * accounting for the length. pg_GSS_write will need this.
715 */
716 major = gss_wrap_size_limit(&minor, conn->gctx, 1, GSS_C_QOP_DEFAULT,
717 PQ_GSS_MAX_PACKET_SIZE - sizeof(uint32),
718 &PqGSSMaxPktSize);
719
720 if (GSS_ERROR(major))
721 {
722 pg_GSS_error(libpq_gettext("GSSAPI size check error"), conn,
723 major, minor);
724 return PGRES_POLLING_FAILED;
725 }
726
727 return PGRES_POLLING_OK;
728 }
729
730 /* Must have output.length > 0 */
731 if (output.length > PQ_GSS_AUTH_BUFFER_SIZE - sizeof(uint32))
732 {
733 libpq_append_conn_error(conn, "client tried to send oversize GSSAPI packet (%zu > %zu)",
734 (size_t) output.length,
735 PQ_GSS_AUTH_BUFFER_SIZE - sizeof(uint32));
736 gss_release_buffer(&minor, &output);
737 return PGRES_POLLING_FAILED;
738 }
739
740 /* Queue the token for writing */
741 netlen = pg_hton32(output.length);
742
743 memcpy(PqGSSSendBuffer, &netlen, sizeof(uint32));
744 PqGSSSendLength += sizeof(uint32);
745
746 memcpy(PqGSSSendBuffer + PqGSSSendLength, output.value, output.length);
747 PqGSSSendLength += output.length;
748
749 /* We don't bother with PqGSSSendConsumed here */
750
751 /* Release buffer storage allocated by GSSAPI */
752 gss_release_buffer(&minor, &output);
753
754 /* Ask to be called again to write data */
755 return PGRES_POLLING_WRITING;
756 }
757
758 /*
759 * GSSAPI Information functions.
760 */
761
762 /*
763 * Return the GSSAPI Context itself.
764 */
765 void *
766 PQgetgssctx(PGconn *conn)
767 {
768 if (!conn)
769 return NULL;
770
771 return conn->gctx;
772 }
773
774 /*
775 * Return true if GSSAPI encryption is in use.
776 */
777 int
778 PQgssEncInUse(PGconn *conn)
779 {
780 if (!conn || !conn->gctx)
781 return 0;
782
783 return conn->gssenc;
784 }