Fix column-privilege leak in error-message paths

While building error messages to return to the user,
BuildIndexValueDescription, ExecBuildSlotValueDescription and
ri_ReportViolation would happily include the entire key or entire row in
the result returned to the user, even if the user didn't have access to
view all of the columns being included.

Instead, include only those columns which the user is providing or which
the user has select rights on.  If the user does not have any rights
to view the table or any of the columns involved then no detail is
provided and a NULL value is returned from BuildIndexValueDescription
and ExecBuildSlotValueDescription.  Note that, for key cases, the user
must have access to all of the columns for the key to be shown; a
partial key will not be returned.

Back-patch all the way, as column-level privileges are now in all
supported versions.

This has been assigned CVE-2014-8161, but since the issue and the patch
have already been publicized on pgsql-hackers, there's no point in trying
to hide this commit.

diff --git a/src/backend/access/index/genam.c b/src/backend/access/index/genam.c
index 850008b3407bf76a4024974cad03eb96d2692489..2520051e8601c95f147deb09fa3ab9943946c8ea 100644 (file)
--- a/src/backend/access/index/genam.c
+++ b/src/backend/access/index/genam.c
@@ -25,10 +25,12 @@
 #include "lib/stringinfo.h"
 #include "miscadmin.h"
 #include "storage/bufmgr.h"
+#include "utils/acl.h"
 #include "utils/builtins.h"
 #include "utils/lsyscache.h"
 #include "utils/rel.h"
 #include "utils/snapmgr.h"
+#include "utils/syscache.h"
 #include "utils/tqual.h"
 
 
@@ -154,6 +156,11 @@ IndexScanEnd(IndexScanDesc scan)
  * form "(key_name, ...)=(key_value, ...)".  This is currently used
  * for building unique-constraint and exclusion-constraint error messages.
  *
+ * Note that if the user does not have permissions to view all of the
+ * columns involved then a NULL is returned.  Returning a partial key seems
+ * unlikely to be useful and we have no way to know which of the columns the
+ * user provided (unlike in ExecBuildSlotValueDescription).
+ *
  * The passed-in values/nulls arrays are the "raw" input to the index AM,
  * e.g. results of FormIndexDatum --- this is not necessarily what is stored
  * in the index, but it's what the user perceives to be stored.
@@ -163,13 +170,62 @@ BuildIndexValueDescription(Relation indexRelation,
                           Datum *values, bool *isnull)
 {
    StringInfoData buf;
+   Form_pg_index idxrec;
+   HeapTuple   ht_idx;
    int         natts = indexRelation->rd_rel->relnatts;
    int         i;
+   int         keyno;
+   Oid         indexrelid = RelationGetRelid(indexRelation);
+   Oid         indrelid;
+   AclResult   aclresult;
+
+   /*
+    * Check permissions- if the user does not have access to view all of the
+    * key columns then return NULL to avoid leaking data.
+    *
+    * First we need to check table-level SELECT access and then, if
+    * there is no access there, check column-level permissions.
+    */
+
+   /*
+    * Fetch the pg_index tuple by the Oid of the index
+    */
+   ht_idx = SearchSysCache1(INDEXRELID, ObjectIdGetDatum(indexrelid));
+   if (!HeapTupleIsValid(ht_idx))
+       elog(ERROR, "cache lookup failed for index %u", indexrelid);
+   idxrec = (Form_pg_index) GETSTRUCT(ht_idx);
+
+   indrelid = idxrec->indrelid;
+   Assert(indexrelid == idxrec->indexrelid);
+
+   /* Table-level SELECT is enough, if the user has it */
+   aclresult = pg_class_aclcheck(indrelid, GetUserId(), ACL_SELECT);
+   if (aclresult != ACLCHECK_OK)
+   {
+       /*
+        * No table-level access, so step through the columns in the
+        * index and make sure the user has SELECT rights on all of them.
+        */
+       for (keyno = 0; keyno < idxrec->indnatts; keyno++)
+       {
+           AttrNumber  attnum = idxrec->indkey.values[keyno];
+
+           aclresult = pg_attribute_aclcheck(indrelid, attnum, GetUserId(),
+                                             ACL_SELECT);
+
+           if (aclresult != ACLCHECK_OK)
+           {
+               /* No access, so clean up and return */
+               ReleaseSysCache(ht_idx);
+               return NULL;
+           }
+       }
+   }
+   ReleaseSysCache(ht_idx);
 
    initStringInfo(&buf);
    appendStringInfo(&buf, "(%s)=(",
-                    pg_get_indexdef_columns(RelationGetRelid(indexRelation),
-                                            true));
+                    pg_get_indexdef_columns(indexrelid, true));
 
    for (i = 0; i < natts; i++)
    {

diff --git a/src/backend/access/nbtree/nbtinsert.c b/src/backend/access/nbtree/nbtinsert.c
index 59d7006c94e9a308992d22f54bb09038408c2994..56313dc6c8d2d79cf51601f983ac07d09490f370 100644 (file)
--- a/src/backend/access/nbtree/nbtinsert.c
+++ b/src/backend/access/nbtree/nbtinsert.c
@@ -388,16 +388,20 @@ _bt_check_unique(Relation rel, IndexTuple itup, Relation heapRel,
                    {
                        Datum       values[INDEX_MAX_KEYS];
                        bool        isnull[INDEX_MAX_KEYS];
+                       char       *key_desc;
 
                        index_deform_tuple(itup, RelationGetDescr(rel),
                                           values, isnull);
+
+                       key_desc = BuildIndexValueDescription(rel, values,
+                                                             isnull);
+
                        ereport(ERROR,
                                (errcode(ERRCODE_UNIQUE_VIOLATION),
                                 errmsg("duplicate key value violates unique constraint \"%s\"",
                                        RelationGetRelationName(rel)),
-                                errdetail("Key %s already exists.",
-                                          BuildIndexValueDescription(rel,
-                                                           values, isnull)),
+                                key_desc ? errdetail("Key %s already exists.",
+                                                     key_desc) : 0,
                                 errtableconstraint(heapRel,
                                             RelationGetRelationName(rel))));
                    }

diff --git a/src/backend/commands/copy.c b/src/backend/commands/copy.c
index fbd7492a73f659892cc3a68b5f5cc39c4d2cd728..9ab1e1989fb7fe277171bdc9f5a83831de30d3e8 100644 (file)
--- a/src/backend/commands/copy.c
+++ b/src/backend/commands/copy.c
@@ -160,6 +160,7 @@ typedef struct CopyStateData
    int        *defmap;         /* array of default att numbers */
    ExprState **defexprs;       /* array of default att expressions */
    bool        volatile_defexprs;      /* is any of defexprs volatile? */
+   List       *range_table;
 
    /*
     * These variables are used to reduce overhead in textual COPY FROM.
@@ -784,6 +785,7 @@ DoCopy(const CopyStmt *stmt, const char *queryString, uint64 *processed)
    bool        pipe = (stmt->filename == NULL);
    Relation    rel;
    Oid         relid;
+   RangeTblEntry *rte;
 
    /* Disallow COPY to/from file or program except to superusers. */
    if (!pipe && !superuser())
@@ -806,7 +808,6 @@ DoCopy(const CopyStmt *stmt, const char *queryString, uint64 *processed)
    {
        TupleDesc   tupDesc;
        AclMode     required_access = (is_from ? ACL_INSERT : ACL_SELECT);
-       RangeTblEntry *rte;
        List       *attnums;
        ListCell   *cur;
 
@@ -856,6 +857,7 @@ DoCopy(const CopyStmt *stmt, const char *queryString, uint64 *processed)
 
        cstate = BeginCopyFrom(rel, stmt->filename, stmt->is_program,
                               stmt->attlist, stmt->options);
+       cstate->range_table = list_make1(rte);
        *processed = CopyFrom(cstate);  /* copy from file to database */
        EndCopyFrom(cstate);
    }
@@ -864,6 +866,7 @@ DoCopy(const CopyStmt *stmt, const char *queryString, uint64 *processed)
        cstate = BeginCopyTo(rel, stmt->query, queryString,
                             stmt->filename, stmt->is_program,
                             stmt->attlist, stmt->options);
+       cstate->range_table = list_make1(rte);
        *processed = DoCopyTo(cstate);  /* copy from database to file */
        EndCopyTo(cstate);
    }
@@ -2184,6 +2187,7 @@ CopyFrom(CopyState cstate)
    estate->es_result_relations = resultRelInfo;
    estate->es_num_result_relations = 1;
    estate->es_result_relation_info = resultRelInfo;
+   estate->es_range_table = cstate->range_table;
 
    /* Set up a tuple slot too */
    myslot = ExecInitExtraTupleSlot(estate);

diff --git a/src/backend/commands/matview.c b/src/backend/commands/matview.c
index 93b972e9b8f1edd516bb1ff67cb8421ccf1160b2..dee8629c3684e807f174788702344108528e22b7 100644 (file)
--- a/src/backend/commands/matview.c
+++ b/src/backend/commands/matview.c
@@ -586,6 +586,13 @@ refresh_by_match_merge(Oid matviewOid, Oid tempOid, Oid relowner,
        elog(ERROR, "SPI_exec failed: %s", querybuf.data);
    if (SPI_processed > 0)
    {
+       /*
+        * Note that this ereport() is returning data to the user.  Generally,
+        * we would want to make sure that the user has been granted access to
+        * this data.  However, REFRESH MAT VIEW is only able to be run by the
+        * owner of the mat view (or a superuser) and therefore there is no
+        * need to check for access to data in the mat view.
+        */
        ereport(ERROR,
                (errcode(ERRCODE_CARDINALITY_VIOLATION),
                 errmsg("new data for \"%s\" contains duplicate rows without any null columns",

diff --git a/src/backend/commands/trigger.c b/src/backend/commands/trigger.c
index 9bf0098b6cbb81bc22b031802d473a3b6989f5bf..bf32b4a92b5eda97d96d11d6632883c2fa4571fa 100644 (file)
--- a/src/backend/commands/trigger.c
+++ b/src/backend/commands/trigger.c
@@ -65,6 +65,12 @@ int          SessionReplicationRole = SESSION_REPLICATION_ROLE_ORIGIN;
 /* How many levels deep into trigger execution are we? */
 static int MyTriggerDepth = 0;
 
+/*
+ * Note that this macro also exists in executor/execMain.c.  There does not
+ * appear to be any good header to put it into, given the structures that
+ * it uses, so we let them be duplicated.  Be sure to update both if one needs
+ * to be changed, however.
+ */
 #define GetModifiedColumns(relinfo, estate) \
    (rt_fetch((relinfo)->ri_RangeTableIndex, (estate)->es_range_table)->modifiedCols)
 

diff --git a/src/backend/executor/execMain.c b/src/backend/executor/execMain.c
index 4c55551d21a676d76167940cb9bb48e565d6ca37..bf82b449d5f29cbf80c9366fb46c7e3ef90b5944 100644 (file)
--- a/src/backend/executor/execMain.c
+++ b/src/backend/executor/execMain.c
@@ -82,12 +82,23 @@ static void ExecutePlan(EState *estate, PlanState *planstate,
            DestReceiver *dest);
 static bool ExecCheckRTEPerms(RangeTblEntry *rte);
 static void ExecCheckXactReadOnly(PlannedStmt *plannedstmt);
-static char *ExecBuildSlotValueDescription(TupleTableSlot *slot,
+static char *ExecBuildSlotValueDescription(Oid reloid,
+                             TupleTableSlot *slot,
                              TupleDesc tupdesc,
+                             Bitmapset *modifiedCols,
                              int maxfieldlen);
 static void EvalPlanQualStart(EPQState *epqstate, EState *parentestate,
                  Plan *planTree);
 
+/*
+ * Note that this macro also exists in commands/trigger.c.  There does not
+ * appear to be any good header to put it into, given the structures that
+ * it uses, so we let them be duplicated.  Be sure to update both if one needs
+ * to be changed, however.
+ */
+#define GetModifiedColumns(relinfo, estate) \
+   (rt_fetch((relinfo)->ri_RangeTableIndex, (estate)->es_range_table)->modifiedCols)
+
 /* end of local decls */
 
 
@@ -1602,15 +1613,24 @@ ExecConstraints(ResultRelInfo *resultRelInfo,
        {
            if (tupdesc->attrs[attrChk - 1]->attnotnull &&
                slot_attisnull(slot, attrChk))
+           {
+               char       *val_desc;
+               Bitmapset  *modifiedCols;
+
+               modifiedCols = GetModifiedColumns(resultRelInfo, estate);
+               val_desc = ExecBuildSlotValueDescription(RelationGetRelid(rel),
+                                                        slot,
+                                                        tupdesc,
+                                                        modifiedCols,
+                                                        64);
+
                ereport(ERROR,
                        (errcode(ERRCODE_NOT_NULL_VIOLATION),
                         errmsg("null value in column \"%s\" violates not-null constraint",
                              NameStr(tupdesc->attrs[attrChk - 1]->attname)),
-                        errdetail("Failing row contains %s.",
-                                  ExecBuildSlotValueDescription(slot,
-                                                                tupdesc,
-                                                                64)),
+                        val_desc ? errdetail("Failing row contains %s.", val_desc) : 0,
                         errtablecol(rel, attrChk)));
+           }
        }
    }
 
@@ -1619,15 +1639,23 @@ ExecConstraints(ResultRelInfo *resultRelInfo,
        const char *failed;
 
        if ((failed = ExecRelCheck(resultRelInfo, slot, estate)) != NULL)
+       {
+           char       *val_desc;
+           Bitmapset  *modifiedCols;
+
+           modifiedCols = GetModifiedColumns(resultRelInfo, estate);
+           val_desc = ExecBuildSlotValueDescription(RelationGetRelid(rel),
+                                                    slot,
+                                                    tupdesc,
+                                                    modifiedCols,
+                                                    64);
            ereport(ERROR,
                    (errcode(ERRCODE_CHECK_VIOLATION),
                     errmsg("new row for relation \"%s\" violates check constraint \"%s\"",
                            RelationGetRelationName(rel), failed),
-                    errdetail("Failing row contains %s.",
-                              ExecBuildSlotValueDescription(slot,
-                                                            tupdesc,
-                                                            64)),
+                    val_desc ? errdetail("Failing row contains %s.", val_desc) : 0,
                     errtableconstraint(rel, failed)));
+       }
    }
 }
 
@@ -1638,6 +1666,8 @@ void
 ExecWithCheckOptions(ResultRelInfo *resultRelInfo,
                     TupleTableSlot *slot, EState *estate)
 {
+   Relation    rel = resultRelInfo->ri_RelationDesc;
+   TupleDesc   tupdesc = RelationGetDescr(rel);
    ExprContext *econtext;
    ListCell   *l1,
               *l2;
@@ -1666,14 +1696,24 @@ ExecWithCheckOptions(ResultRelInfo *resultRelInfo,
         * above for CHECK constraints).
         */
        if (!ExecQual((List *) wcoExpr, econtext, false))
+       {
+           char       *val_desc;
+           Bitmapset  *modifiedCols;
+
+           modifiedCols = GetModifiedColumns(resultRelInfo, estate);
+           val_desc = ExecBuildSlotValueDescription(RelationGetRelid(rel),
+                                                    slot,
+                                                    tupdesc,
+                                                    modifiedCols,
+                                                    64);
+
            ereport(ERROR,
                    (errcode(ERRCODE_WITH_CHECK_OPTION_VIOLATION),
                 errmsg("new row violates WITH CHECK OPTION for view \"%s\"",
                        wco->viewname),
-                    errdetail("Failing row contains %s.",
-                              ExecBuildSlotValueDescription(slot,
-                           RelationGetDescr(resultRelInfo->ri_RelationDesc),
-                                                            64))));
+                   val_desc ? errdetail("Failing row contains %s.", val_desc) :
+                              0));
+       }
    }
 }
 
@@ -1689,25 +1729,56 @@ ExecWithCheckOptions(ResultRelInfo *resultRelInfo,
  * dropped columns.  We used to use the slot's tuple descriptor to decode the
  * data, but the slot's descriptor doesn't identify dropped columns, so we
  * now need to be passed the relation's descriptor.
+ *
+ * Note that, like BuildIndexValueDescription, if the user does not have
+ * permission to view any of the columns involved, a NULL is returned.  Unlike
+ * BuildIndexValueDescription, if the user has access to view a subset of the
+ * column involved, that subset will be returned with a key identifying which
+ * columns they are.
  */
 static char *
-ExecBuildSlotValueDescription(TupleTableSlot *slot,
+ExecBuildSlotValueDescription(Oid reloid,
+                             TupleTableSlot *slot,
                              TupleDesc tupdesc,
+                             Bitmapset *modifiedCols,
                              int maxfieldlen)
 {
    StringInfoData buf;
+   StringInfoData collist;
    bool        write_comma = false;
+   bool        write_comma_collist = false;
    int         i;
-
-   /* Make sure the tuple is fully deconstructed */
-   slot_getallattrs(slot);
+   AclResult   aclresult;
+   bool        table_perm = false;
+   bool        any_perm = false;
 
    initStringInfo(&buf);
 
    appendStringInfoChar(&buf, '(');
 
+   /*
+    * Check if the user has permissions to see the row.  Table-level SELECT
+    * allows access to all columns.  If the user does not have table-level
+    * SELECT then we check each column and include those the user has SELECT
+    * rights on.  Additionally, we always include columns the user provided
+    * data for.
+    */
+   aclresult = pg_class_aclcheck(reloid, GetUserId(), ACL_SELECT);
+   if (aclresult != ACLCHECK_OK)
+   {
+       /* Set up the buffer for the column list */
+       initStringInfo(&collist);
+       appendStringInfoChar(&collist, '(');
+   }
+   else
+       table_perm = any_perm = true;
+
+   /* Make sure the tuple is fully deconstructed */
+   slot_getallattrs(slot);
+
    for (i = 0; i < tupdesc->natts; i++)
    {
+       bool        column_perm = false;
        char       *val;
        int         vallen;
 
@@ -1715,37 +1786,76 @@ ExecBuildSlotValueDescription(TupleTableSlot *slot,
        if (tupdesc->attrs[i]->attisdropped)
            continue;
 
-       if (slot->tts_isnull[i])
-           val = "null";
-       else
+       if (!table_perm)
        {
-           Oid         foutoid;
-           bool        typisvarlena;
+           /*
+            * No table-level SELECT, so need to make sure they either have
+            * SELECT rights on the column or that they have provided the
+            * data for the column.  If not, omit this column from the error
+            * message.
+            */
+           aclresult = pg_attribute_aclcheck(reloid, tupdesc->attrs[i]->attnum,
+                                             GetUserId(), ACL_SELECT);
+           if (bms_is_member(tupdesc->attrs[i]->attnum - FirstLowInvalidHeapAttributeNumber,
+                             modifiedCols) || aclresult == ACLCHECK_OK)
+           {
+               column_perm = any_perm = true;
 
-           getTypeOutputInfo(tupdesc->attrs[i]->atttypid,
-                             &foutoid, &typisvarlena);
-           val = OidOutputFunctionCall(foutoid, slot->tts_values[i]);
-       }
+               if (write_comma_collist)
+                   appendStringInfoString(&collist, ", ");
+               else
+                   write_comma_collist = true;
 
-       if (write_comma)
-           appendStringInfoString(&buf, ", ");
-       else
-           write_comma = true;
+               appendStringInfoString(&collist, NameStr(tupdesc->attrs[i]->attname));
+           }
+       }
 
-       /* truncate if needed */
-       vallen = strlen(val);
-       if (vallen <= maxfieldlen)
-           appendStringInfoString(&buf, val);
-       else
+       if (table_perm || column_perm)
        {
-           vallen = pg_mbcliplen(val, vallen, maxfieldlen);
-           appendBinaryStringInfo(&buf, val, vallen);
-           appendStringInfoString(&buf, "...");
+           if (slot->tts_isnull[i])
+               val = "null";
+           else
+           {
+               Oid         foutoid;
+               bool        typisvarlena;
+
+               getTypeOutputInfo(tupdesc->attrs[i]->atttypid,
+                                 &foutoid, &typisvarlena);
+               val = OidOutputFunctionCall(foutoid, slot->tts_values[i]);
+           }
+
+           if (write_comma)
+               appendStringInfoString(&buf, ", ");
+           else
+               write_comma = true;
+
+           /* truncate if needed */
+           vallen = strlen(val);
+           if (vallen <= maxfieldlen)
+               appendStringInfoString(&buf, val);
+           else
+           {
+               vallen = pg_mbcliplen(val, vallen, maxfieldlen);
+               appendBinaryStringInfo(&buf, val, vallen);
+               appendStringInfoString(&buf, "...");
+           }
        }
    }
 
+   /* If we end up with zero columns being returned, then return NULL. */
+   if (!any_perm)
+       return NULL;
+
    appendStringInfoChar(&buf, ')');
 
+   if (!table_perm)
+   {
+       appendStringInfoString(&collist, ") = ");
+       appendStringInfoString(&collist, buf.data);
+
+       return collist.data;
+   }
+
    return buf.data;
 }
 

diff --git a/src/backend/executor/execUtils.c b/src/backend/executor/execUtils.c
index d5e1273e91c35c308aae9fa902556e5842a8f1d5..5c08501ee718f41c3fd59cbf151d8f2dbbfb0ddc 100644 (file)
--- a/src/backend/executor/execUtils.c
+++ b/src/backend/executor/execUtils.c
@@ -1323,8 +1323,10 @@ retry:
                    (errcode(ERRCODE_EXCLUSION_VIOLATION),
                     errmsg("could not create exclusion constraint \"%s\"",
                            RelationGetRelationName(index)),
-                    errdetail("Key %s conflicts with key %s.",
-                              error_new, error_existing),
+                    error_new && error_existing ?
+                       errdetail("Key %s conflicts with key %s.",
+                                 error_new, error_existing) :
+                       errdetail("Key conflicts exist."),
                     errtableconstraint(heap,
                                        RelationGetRelationName(index))));
        else
@@ -1332,8 +1334,10 @@ retry:
                    (errcode(ERRCODE_EXCLUSION_VIOLATION),
                     errmsg("conflicting key value violates exclusion constraint \"%s\"",
                            RelationGetRelationName(index)),
-                    errdetail("Key %s conflicts with existing key %s.",
-                              error_new, error_existing),
+                    error_new && error_existing ?
+                       errdetail("Key %s conflicts with existing key %s.",
+                                 error_new, error_existing) :
+                       errdetail("Key conflicts with existing key."),
                     errtableconstraint(heap,
                                        RelationGetRelationName(index))));
    }

diff --git a/src/backend/utils/adt/ri_triggers.c b/src/backend/utils/adt/ri_triggers.c
index e4d7b2c34b6501e0eb2fb0b0bdbdbeaf46bcfabc..9052052407f82352f76fdba7ddf5629a7258f606 100644 (file)
--- a/src/backend/utils/adt/ri_triggers.c
+++ b/src/backend/utils/adt/ri_triggers.c
@@ -43,6 +43,7 @@
 #include "parser/parse_coerce.h"
 #include "parser/parse_relation.h"
 #include "miscadmin.h"
+#include "utils/acl.h"
 #include "utils/builtins.h"
 #include "utils/fmgroids.h"
 #include "utils/guc.h"
@@ -3170,6 +3171,9 @@ ri_ReportViolation(const RI_ConstraintInfo *riinfo,
    bool        onfk;
    const int16 *attnums;
    int         idx;
+   Oid         rel_oid;
+   AclResult   aclresult;
+   bool        has_perm = true;
 
    if (spi_err)
        ereport(ERROR,
@@ -3188,37 +3192,68 @@ ri_ReportViolation(const RI_ConstraintInfo *riinfo,
    if (onfk)
    {
        attnums = riinfo->fk_attnums;
+       rel_oid = fk_rel->rd_id;
        if (tupdesc == NULL)
            tupdesc = fk_rel->rd_att;
    }
    else
    {
        attnums = riinfo->pk_attnums;
+       rel_oid = pk_rel->rd_id;
        if (tupdesc == NULL)
            tupdesc = pk_rel->rd_att;
    }
 
-   /* Get printable versions of the keys involved */
-   initStringInfo(&key_names);
-   initStringInfo(&key_values);
-   for (idx = 0; idx < riinfo->nkeys; idx++)
+   /*
+    * Check permissions- if the user does not have access to view the data in
+    * any of the key columns then we don't include the errdetail() below.
+    *
+    * Check table-level permissions first and, failing that, column-level
+    * privileges.
+    */
+   aclresult = pg_class_aclcheck(rel_oid, GetUserId(), ACL_SELECT);
+   if (aclresult != ACLCHECK_OK)
    {
-       int         fnum = attnums[idx];
-       char       *name,
-                  *val;
+       /* Try for column-level permissions */
+       for (idx = 0; idx < riinfo->nkeys; idx++)
+       {
+           aclresult = pg_attribute_aclcheck(rel_oid, attnums[idx],
+                                             GetUserId(),
+                                             ACL_SELECT);
 
-       name = SPI_fname(tupdesc, fnum);
-       val = SPI_getvalue(violator, tupdesc, fnum);
-       if (!val)
-           val = "null";
+           /* No access to the key */
+           if (aclresult != ACLCHECK_OK)
+           {
+               has_perm = false;
+               break;
+           }
+       }
+   }
 
-       if (idx > 0)
+   if (has_perm)
+   {
+       /* Get printable versions of the keys involved */
+       initStringInfo(&key_names);
+       initStringInfo(&key_values);
+       for (idx = 0; idx < riinfo->nkeys; idx++)
        {
-           appendStringInfoString(&key_names, ", ");
-           appendStringInfoString(&key_values, ", ");
+           int         fnum = attnums[idx];
+           char       *name,
+                  *val;
+
+           name = SPI_fname(tupdesc, fnum);
+           val = SPI_getvalue(violator, tupdesc, fnum);
+           if (!val)
+               val = "null";
+
+           if (idx > 0)
+           {
+               appendStringInfoString(&key_names, ", ");
+               appendStringInfoString(&key_values, ", ");
+           }
+           appendStringInfoString(&key_names, name);
+           appendStringInfoString(&key_values, val);
        }
-       appendStringInfoString(&key_names, name);
-       appendStringInfoString(&key_values, val);
    }
 
    if (onfk)
@@ -3227,9 +3262,12 @@ ri_ReportViolation(const RI_ConstraintInfo *riinfo,
                 errmsg("insert or update on table \"%s\" violates foreign key constraint \"%s\"",
                        RelationGetRelationName(fk_rel),
                        NameStr(riinfo->conname)),
-                errdetail("Key (%s)=(%s) is not present in table \"%s\".",
-                          key_names.data, key_values.data,
-                          RelationGetRelationName(pk_rel)),
+                has_perm ?
+                    errdetail("Key (%s)=(%s) is not present in table \"%s\".",
+                              key_names.data, key_values.data,
+                              RelationGetRelationName(pk_rel)) :
+                    errdetail("Key is not present in table \"%s\".",
+                              RelationGetRelationName(pk_rel)),
                 errtableconstraint(fk_rel, NameStr(riinfo->conname))));
    else
        ereport(ERROR,
@@ -3238,8 +3276,11 @@ ri_ReportViolation(const RI_ConstraintInfo *riinfo,
                        RelationGetRelationName(pk_rel),
                        NameStr(riinfo->conname),
                        RelationGetRelationName(fk_rel)),
+                has_perm ?
            errdetail("Key (%s)=(%s) is still referenced from table \"%s\".",
                      key_names.data, key_values.data,
+                     RelationGetRelationName(fk_rel)) :
+                   errdetail("Key is still referenced from table \"%s\".",
                      RelationGetRelationName(fk_rel)),
                 errtableconstraint(fk_rel, NameStr(riinfo->conname))));
 }

diff --git a/src/backend/utils/sort/tuplesort.c b/src/backend/utils/sort/tuplesort.c
index aa0f6d8e047a9c77384d773e8673cf6f39f0cf3d..e78a51fe2283bdebf9e0de40f833bef6a61a1614 100644 (file)
--- a/src/backend/utils/sort/tuplesort.c
+++ b/src/backend/utils/sort/tuplesort.c
@@ -3240,6 +3240,7 @@ comparetup_index_btree(const SortTuple *a, const SortTuple *b,
    {
        Datum       values[INDEX_MAX_KEYS];
        bool        isnull[INDEX_MAX_KEYS];
+       char       *key_desc;
 
        /*
         * Some rather brain-dead implementations of qsort (such as the one in
@@ -3250,13 +3251,15 @@ comparetup_index_btree(const SortTuple *a, const SortTuple *b,
        Assert(tuple1 != tuple2);
 
        index_deform_tuple(tuple1, tupDes, values, isnull);
+
+       key_desc = BuildIndexValueDescription(state->indexRel, values, isnull);
+
        ereport(ERROR,
                (errcode(ERRCODE_UNIQUE_VIOLATION),
                 errmsg("could not create unique index \"%s\"",
                        RelationGetRelationName(state->indexRel)),
-                errdetail("Key %s is duplicated.",
-                          BuildIndexValueDescription(state->indexRel,
-                                                     values, isnull)),
+                key_desc ? errdetail("Key %s is duplicated.", key_desc) :
+                           errdetail("Duplicate keys exist."),
                 errtableconstraint(state->heapRel,
                                 RelationGetRelationName(state->indexRel))));
    }

diff --git a/src/test/regress/expected/privileges.out b/src/test/regress/expected/privileges.out
index 1675075f6824e504e4274a62f3f95c7a5c69f610..639d9f711e9281e3242e816e4a8244f51bba2b4d 100644 (file)
--- a/src/test/regress/expected/privileges.out
+++ b/src/test/regress/expected/privileges.out
@@ -381,6 +381,37 @@ SELECT atest6 FROM atest6; -- ok
 (0 rows)
 
 COPY atest6 TO stdout; -- ok
+-- check error reporting with column privs
+SET SESSION AUTHORIZATION regressuser1;
+CREATE TABLE t1 (c1 int, c2 int, c3 int check (c3 < 5), primary key (c1, c2));
+GRANT SELECT (c1) ON t1 TO regressuser2;
+GRANT INSERT (c1, c2, c3) ON t1 TO regressuser2;
+GRANT UPDATE (c1, c2, c3) ON t1 TO regressuser2;
+-- seed data
+INSERT INTO t1 VALUES (1, 1, 1);
+INSERT INTO t1 VALUES (1, 2, 1);
+INSERT INTO t1 VALUES (2, 1, 2);
+INSERT INTO t1 VALUES (2, 2, 2);
+INSERT INTO t1 VALUES (3, 1, 3);
+SET SESSION AUTHORIZATION regressuser2;
+INSERT INTO t1 (c1, c2) VALUES (1, 1); -- fail, but row not shown
+ERROR:  duplicate key value violates unique constraint "t1_pkey"
+UPDATE t1 SET c2 = 1; -- fail, but row not shown
+ERROR:  duplicate key value violates unique constraint "t1_pkey"
+INSERT INTO t1 (c1, c2) VALUES (null, null); -- fail, but see columns being inserted
+ERROR:  null value in column "c1" violates not-null constraint
+DETAIL:  Failing row contains (c1, c2) = (null, null).
+INSERT INTO t1 (c3) VALUES (null); -- fail, but see columns being inserted or have SELECT
+ERROR:  null value in column "c1" violates not-null constraint
+DETAIL:  Failing row contains (c1, c3) = (null, null).
+INSERT INTO t1 (c1) VALUES (5); -- fail, but see columns being inserted or have SELECT
+ERROR:  null value in column "c2" violates not-null constraint
+DETAIL:  Failing row contains (c1) = (5).
+UPDATE t1 SET c3 = 10; -- fail, but see columns with SELECT rights, or being modified
+ERROR:  new row for relation "t1" violates check constraint "t1_c3_check"
+DETAIL:  Failing row contains (c1, c3) = (1, 10).
+SET SESSION AUTHORIZATION regressuser1;
+DROP TABLE t1;
 -- test column-level privileges when involved with DELETE
 SET SESSION AUTHORIZATION regressuser1;
 ALTER TABLE atest6 ADD COLUMN three integer;

diff --git a/src/test/regress/sql/privileges.sql b/src/test/regress/sql/privileges.sql
index a0ff953c9041c904d3a1127976f4be81bdf6de6f..f97a75a5fdc4677c00b4ac1d9b2b4f10a1584e98 100644 (file)
--- a/src/test/regress/sql/privileges.sql
+++ b/src/test/regress/sql/privileges.sql
@@ -256,6 +256,31 @@ UPDATE atest5 SET one = 1; -- fail
 SELECT atest6 FROM atest6; -- ok
 COPY atest6 TO stdout; -- ok
 
+-- check error reporting with column privs
+SET SESSION AUTHORIZATION regressuser1;
+CREATE TABLE t1 (c1 int, c2 int, c3 int check (c3 < 5), primary key (c1, c2));
+GRANT SELECT (c1) ON t1 TO regressuser2;
+GRANT INSERT (c1, c2, c3) ON t1 TO regressuser2;
+GRANT UPDATE (c1, c2, c3) ON t1 TO regressuser2;
+
+-- seed data
+INSERT INTO t1 VALUES (1, 1, 1);
+INSERT INTO t1 VALUES (1, 2, 1);
+INSERT INTO t1 VALUES (2, 1, 2);
+INSERT INTO t1 VALUES (2, 2, 2);
+INSERT INTO t1 VALUES (3, 1, 3);
+
+SET SESSION AUTHORIZATION regressuser2;
+INSERT INTO t1 (c1, c2) VALUES (1, 1); -- fail, but row not shown
+UPDATE t1 SET c2 = 1; -- fail, but row not shown
+INSERT INTO t1 (c1, c2) VALUES (null, null); -- fail, but see columns being inserted
+INSERT INTO t1 (c3) VALUES (null); -- fail, but see columns being inserted or have SELECT
+INSERT INTO t1 (c1) VALUES (5); -- fail, but see columns being inserted or have SELECT
+UPDATE t1 SET c3 = 10; -- fail, but see columns with SELECT rights, or being modified
+
+SET SESSION AUTHORIZATION regressuser1;
+DROP TABLE t1;
+
 -- test column-level privileges when involved with DELETE
 SET SESSION AUTHORIZATION regressuser1;
 ALTER TABLE atest6 ADD COLUMN three integer;