pg.ddx.io pgsql-committers@postgresql.org mailing list archivehelp / color / mirror / Atom feed
pgsql: Remove misguided SSL key file ownership check in libpq. 6+ messages / 1 participants [nested] [flat]
* pgsql: Remove misguided SSL key file ownership check in libpq. @ 2022-05-26 18:14 Tom Lane <tgl@sss.pgh.pa.us> 0 siblings, 0 replies; 6+ messages in thread From: Tom Lane @ 2022-05-26 18:14 UTC (permalink / raw) To: pgsql-committers@lists.postgresql.org Remove misguided SSL key file ownership check in libpq. Commits a59c79564 et al. tried to sync libpq's SSL key file permissions checks with what we've used for years in the backend. We did not intend to create any new failure cases, but it turns out we did: restricting the key file's ownership breaks cases where the client is allowed to read a key file despite not having the identical UID. In particular a client running as root used to be able to read someone else's key file; and having seen that I suspect that there are other, less-dubious use cases that this restriction breaks on some platforms. We don't really need an ownership check, since if we can read the key file despite its having restricted permissions, it must have the right ownership --- under normal conditions anyway, and the point of this patch is that any additional corner cases where that works should be deemed allowable, as they have been historically. Hence, just drop the ownership check, and rearrange the permissions check to get rid of its faulty assumption that geteuid() can't be zero. (Note that the comparable backend-side code doesn't have to cater for geteuid() == 0, since the server rejects that very early on.) This does have the end result that the permissions safety check used for a root user's private key file is weaker than that used for anyone else's. While odd, root really ought to know what she's doing with file permissions, so I think this is acceptable. Per report from Yogendra Suralkar. Like the previous patch, back-patch to all supported branches. Discussion: https://postgr.es/m/MW3PR15MB3931DF96896DC36D21AFD47CA3D39@MW3PR15MB3931.namprd15.prod.outlook.com Branch ------ REL_12_STABLE Details ------- https://git.postgresql.org/pg/commitdiff/01ab9fb7dee5f9445bae94a942afb6ee9bcccd4f Modified Files -------------- src/backend/libpq/be-secure-common.c | 5 +++-- src/interfaces/libpq/fe-secure-openssl.c | 34 ++++++++++++++++---------------- 2 files changed, 20 insertions(+), 19 deletions(-) ^ permalink raw reply [nested|flat] 6+ messages in thread
* pgsql: Remove misguided SSL key file ownership check in libpq. @ 2022-05-26 18:14 Tom Lane <tgl@sss.pgh.pa.us> 0 siblings, 0 replies; 6+ messages in thread From: Tom Lane @ 2022-05-26 18:14 UTC (permalink / raw) To: pgsql-committers@lists.postgresql.org Remove misguided SSL key file ownership check in libpq. Commits a59c79564 et al. tried to sync libpq's SSL key file permissions checks with what we've used for years in the backend. We did not intend to create any new failure cases, but it turns out we did: restricting the key file's ownership breaks cases where the client is allowed to read a key file despite not having the identical UID. In particular a client running as root used to be able to read someone else's key file; and having seen that I suspect that there are other, less-dubious use cases that this restriction breaks on some platforms. We don't really need an ownership check, since if we can read the key file despite its having restricted permissions, it must have the right ownership --- under normal conditions anyway, and the point of this patch is that any additional corner cases where that works should be deemed allowable, as they have been historically. Hence, just drop the ownership check, and rearrange the permissions check to get rid of its faulty assumption that geteuid() can't be zero. (Note that the comparable backend-side code doesn't have to cater for geteuid() == 0, since the server rejects that very early on.) This does have the end result that the permissions safety check used for a root user's private key file is weaker than that used for anyone else's. While odd, root really ought to know what she's doing with file permissions, so I think this is acceptable. Per report from Yogendra Suralkar. Like the previous patch, back-patch to all supported branches. Discussion: https://postgr.es/m/MW3PR15MB3931DF96896DC36D21AFD47CA3D39@MW3PR15MB3931.namprd15.prod.outlook.com Branch ------ REL_14_STABLE Details ------- https://git.postgresql.org/pg/commitdiff/b4be4a082bde8b4f3caca6fa3127af005720f2d8 Modified Files -------------- src/backend/libpq/be-secure-common.c | 5 +++-- src/interfaces/libpq/fe-secure-openssl.c | 34 ++++++++++++++++---------------- 2 files changed, 20 insertions(+), 19 deletions(-) ^ permalink raw reply [nested|flat] 6+ messages in thread
* pgsql: Remove misguided SSL key file ownership check in libpq. @ 2022-05-26 18:14 Tom Lane <tgl@sss.pgh.pa.us> 0 siblings, 0 replies; 6+ messages in thread From: Tom Lane @ 2022-05-26 18:14 UTC (permalink / raw) To: pgsql-committers@lists.postgresql.org Remove misguided SSL key file ownership check in libpq. Commits a59c79564 et al. tried to sync libpq's SSL key file permissions checks with what we've used for years in the backend. We did not intend to create any new failure cases, but it turns out we did: restricting the key file's ownership breaks cases where the client is allowed to read a key file despite not having the identical UID. In particular a client running as root used to be able to read someone else's key file; and having seen that I suspect that there are other, less-dubious use cases that this restriction breaks on some platforms. We don't really need an ownership check, since if we can read the key file despite its having restricted permissions, it must have the right ownership --- under normal conditions anyway, and the point of this patch is that any additional corner cases where that works should be deemed allowable, as they have been historically. Hence, just drop the ownership check, and rearrange the permissions check to get rid of its faulty assumption that geteuid() can't be zero. (Note that the comparable backend-side code doesn't have to cater for geteuid() == 0, since the server rejects that very early on.) This does have the end result that the permissions safety check used for a root user's private key file is weaker than that used for anyone else's. While odd, root really ought to know what she's doing with file permissions, so I think this is acceptable. Per report from Yogendra Suralkar. Like the previous patch, back-patch to all supported branches. Discussion: https://postgr.es/m/MW3PR15MB3931DF96896DC36D21AFD47CA3D39@MW3PR15MB3931.namprd15.prod.outlook.com Branch ------ REL_10_STABLE Details ------- https://git.postgresql.org/pg/commitdiff/ef54a65762f02eaeb8b2b30414ace55b203bce01 Modified Files -------------- src/backend/libpq/be-secure-openssl.c | 5 +++-- src/interfaces/libpq/fe-secure-openssl.c | 34 ++++++++++++++++---------------- 2 files changed, 20 insertions(+), 19 deletions(-) ^ permalink raw reply [nested|flat] 6+ messages in thread
* pgsql: Remove misguided SSL key file ownership check in libpq. @ 2022-05-26 18:14 Tom Lane <tgl@sss.pgh.pa.us> 0 siblings, 0 replies; 6+ messages in thread From: Tom Lane @ 2022-05-26 18:14 UTC (permalink / raw) To: pgsql-committers@lists.postgresql.org Remove misguided SSL key file ownership check in libpq. Commits a59c79564 et al. tried to sync libpq's SSL key file permissions checks with what we've used for years in the backend. We did not intend to create any new failure cases, but it turns out we did: restricting the key file's ownership breaks cases where the client is allowed to read a key file despite not having the identical UID. In particular a client running as root used to be able to read someone else's key file; and having seen that I suspect that there are other, less-dubious use cases that this restriction breaks on some platforms. We don't really need an ownership check, since if we can read the key file despite its having restricted permissions, it must have the right ownership --- under normal conditions anyway, and the point of this patch is that any additional corner cases where that works should be deemed allowable, as they have been historically. Hence, just drop the ownership check, and rearrange the permissions check to get rid of its faulty assumption that geteuid() can't be zero. (Note that the comparable backend-side code doesn't have to cater for geteuid() == 0, since the server rejects that very early on.) This does have the end result that the permissions safety check used for a root user's private key file is weaker than that used for anyone else's. While odd, root really ought to know what she's doing with file permissions, so I think this is acceptable. Per report from Yogendra Suralkar. Like the previous patch, back-patch to all supported branches. Discussion: https://postgr.es/m/MW3PR15MB3931DF96896DC36D21AFD47CA3D39@MW3PR15MB3931.namprd15.prod.outlook.com Branch ------ master Details ------- https://git.postgresql.org/pg/commitdiff/2b65de7fc296bb5060c8d4ae8cb680f71364fbe0 Modified Files -------------- src/backend/libpq/be-secure-common.c | 5 +++-- src/interfaces/libpq/fe-secure-openssl.c | 34 ++++++++++++++++---------------- 2 files changed, 20 insertions(+), 19 deletions(-) ^ permalink raw reply [nested|flat] 6+ messages in thread
* pgsql: Remove misguided SSL key file ownership check in libpq. @ 2022-05-26 18:14 Tom Lane <tgl@sss.pgh.pa.us> 0 siblings, 0 replies; 6+ messages in thread From: Tom Lane @ 2022-05-26 18:14 UTC (permalink / raw) To: pgsql-committers@lists.postgresql.org Remove misguided SSL key file ownership check in libpq. Commits a59c79564 et al. tried to sync libpq's SSL key file permissions checks with what we've used for years in the backend. We did not intend to create any new failure cases, but it turns out we did: restricting the key file's ownership breaks cases where the client is allowed to read a key file despite not having the identical UID. In particular a client running as root used to be able to read someone else's key file; and having seen that I suspect that there are other, less-dubious use cases that this restriction breaks on some platforms. We don't really need an ownership check, since if we can read the key file despite its having restricted permissions, it must have the right ownership --- under normal conditions anyway, and the point of this patch is that any additional corner cases where that works should be deemed allowable, as they have been historically. Hence, just drop the ownership check, and rearrange the permissions check to get rid of its faulty assumption that geteuid() can't be zero. (Note that the comparable backend-side code doesn't have to cater for geteuid() == 0, since the server rejects that very early on.) This does have the end result that the permissions safety check used for a root user's private key file is weaker than that used for anyone else's. While odd, root really ought to know what she's doing with file permissions, so I think this is acceptable. Per report from Yogendra Suralkar. Like the previous patch, back-patch to all supported branches. Discussion: https://postgr.es/m/MW3PR15MB3931DF96896DC36D21AFD47CA3D39@MW3PR15MB3931.namprd15.prod.outlook.com Branch ------ REL_13_STABLE Details ------- https://git.postgresql.org/pg/commitdiff/9e3dbc6fd9a38cd7c72289f7facd639976484e45 Modified Files -------------- src/backend/libpq/be-secure-common.c | 5 +++-- src/interfaces/libpq/fe-secure-openssl.c | 34 ++++++++++++++++---------------- 2 files changed, 20 insertions(+), 19 deletions(-) ^ permalink raw reply [nested|flat] 6+ messages in thread
* pgsql: Remove misguided SSL key file ownership check in libpq. @ 2022-05-26 18:14 Tom Lane <tgl@sss.pgh.pa.us> 0 siblings, 0 replies; 6+ messages in thread From: Tom Lane @ 2022-05-26 18:14 UTC (permalink / raw) To: pgsql-committers@lists.postgresql.org Remove misguided SSL key file ownership check in libpq. Commits a59c79564 et al. tried to sync libpq's SSL key file permissions checks with what we've used for years in the backend. We did not intend to create any new failure cases, but it turns out we did: restricting the key file's ownership breaks cases where the client is allowed to read a key file despite not having the identical UID. In particular a client running as root used to be able to read someone else's key file; and having seen that I suspect that there are other, less-dubious use cases that this restriction breaks on some platforms. We don't really need an ownership check, since if we can read the key file despite its having restricted permissions, it must have the right ownership --- under normal conditions anyway, and the point of this patch is that any additional corner cases where that works should be deemed allowable, as they have been historically. Hence, just drop the ownership check, and rearrange the permissions check to get rid of its faulty assumption that geteuid() can't be zero. (Note that the comparable backend-side code doesn't have to cater for geteuid() == 0, since the server rejects that very early on.) This does have the end result that the permissions safety check used for a root user's private key file is weaker than that used for anyone else's. While odd, root really ought to know what she's doing with file permissions, so I think this is acceptable. Per report from Yogendra Suralkar. Like the previous patch, back-patch to all supported branches. Discussion: https://postgr.es/m/MW3PR15MB3931DF96896DC36D21AFD47CA3D39@MW3PR15MB3931.namprd15.prod.outlook.com Branch ------ REL_11_STABLE Details ------- https://git.postgresql.org/pg/commitdiff/a44bc8b8f421d8696eaa796884acb6ed6cc6c670 Modified Files -------------- src/backend/libpq/be-secure-common.c | 5 +++-- src/interfaces/libpq/fe-secure-openssl.c | 34 ++++++++++++++++---------------- 2 files changed, 20 insertions(+), 19 deletions(-) ^ permalink raw reply [nested|flat] 6+ messages in thread
end of thread, other threads:[~2022-05-26 18:14 UTC | newest] Thread overview: 6+ messages (download: mbox mbox.gz follow: Atom feed) -- links below jump to the message on this page -- 2022-05-26 18:14 pgsql: Remove misguided SSL key file ownership check in libpq. Tom Lane <tgl@sss.pgh.pa.us> 2022-05-26 18:14 pgsql: Remove misguided SSL key file ownership check in libpq. Tom Lane <tgl@sss.pgh.pa.us> 2022-05-26 18:14 pgsql: Remove misguided SSL key file ownership check in libpq. Tom Lane <tgl@sss.pgh.pa.us> 2022-05-26 18:14 pgsql: Remove misguided SSL key file ownership check in libpq. Tom Lane <tgl@sss.pgh.pa.us> 2022-05-26 18:14 pgsql: Remove misguided SSL key file ownership check in libpq. Tom Lane <tgl@sss.pgh.pa.us> 2022-05-26 18:14 pgsql: Remove misguided SSL key file ownership check in libpq. Tom Lane <tgl@sss.pgh.pa.us>
This inbox is served by DDX for PostgreSQL; see mirroring instructions for how to clone and mirror all data and code used for this inbox