LCOV - code coverage report
Current view: top level - contrib/pgcrypto - pgp-mpi.c (source / functions) Hit Total Coverage
Test: PostgreSQL 13beta1 Lines: 51 56 91.1 %
Date: 2020-06-01 09:07:10 Functions: 7 7 100.0 %
Legend: Lines: hit not hit

          Line data    Source code
       1             : /*
       2             :  * pgp-mpi.c
       3             :  *    OpenPGP MPI helper functions.
       4             :  *
       5             :  * Copyright (c) 2005 Marko Kreen
       6             :  * All rights reserved.
       7             :  *
       8             :  * Redistribution and use in source and binary forms, with or without
       9             :  * modification, are permitted provided that the following conditions
      10             :  * are met:
      11             :  * 1. Redistributions of source code must retain the above copyright
      12             :  *    notice, this list of conditions and the following disclaimer.
      13             :  * 2. Redistributions in binary form must reproduce the above copyright
      14             :  *    notice, this list of conditions and the following disclaimer in the
      15             :  *    documentation and/or other materials provided with the distribution.
      16             :  *
      17             :  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
      18             :  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
      19             :  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
      20             :  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
      21             :  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
      22             :  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
      23             :  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
      24             :  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
      25             :  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
      26             :  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
      27             :  * SUCH DAMAGE.
      28             :  *
      29             :  * contrib/pgcrypto/pgp-mpi.c
      30             :  */
      31             : #include "postgres.h"
      32             : 
      33             : #include "pgp.h"
      34             : #include "px.h"
      35             : 
      36             : int
      37         344 : pgp_mpi_alloc(int bits, PGP_MPI **mpi)
      38             : {
      39             :     PGP_MPI    *n;
      40         344 :     int         len = (bits + 7) / 8;
      41             : 
      42         344 :     if (bits < 0 || bits > 0xFFFF)
      43             :     {
      44           0 :         px_debug("pgp_mpi_alloc: unreasonable request: bits=%d", bits);
      45           0 :         return PXE_PGP_CORRUPT_DATA;
      46             :     }
      47         344 :     n = px_alloc(sizeof(*n) + len);
      48         344 :     n->bits = bits;
      49         344 :     n->bytes = len;
      50         344 :     n->data = (uint8 *) (n) + sizeof(*n);
      51         344 :     *mpi = n;
      52         344 :     return 0;
      53             : }
      54             : 
      55             : int
      56          12 : pgp_mpi_create(uint8 *data, int bits, PGP_MPI **mpi)
      57             : {
      58             :     int         res;
      59             :     PGP_MPI    *n;
      60             : 
      61          12 :     res = pgp_mpi_alloc(bits, &n);
      62          12 :     if (res < 0)
      63           0 :         return res;
      64          12 :     memcpy(n->data, data, n->bytes);
      65          12 :     *mpi = n;
      66          12 :     return 0;
      67             : }
      68             : 
      69             : int
      70         396 : pgp_mpi_free(PGP_MPI *mpi)
      71             : {
      72         396 :     if (mpi == NULL)
      73          58 :         return 0;
      74         338 :     px_memset(mpi, 0, sizeof(*mpi) + mpi->bytes);
      75         338 :     px_free(mpi);
      76         338 :     return 0;
      77             : }
      78             : 
      79             : int
      80         284 : pgp_mpi_read(PullFilter *src, PGP_MPI **mpi)
      81             : {
      82             :     int         res;
      83             :     uint8       hdr[2];
      84             :     int         bits;
      85             :     PGP_MPI    *n;
      86             : 
      87         284 :     res = pullf_read_fixed(src, 2, hdr);
      88         284 :     if (res < 0)
      89           0 :         return res;
      90         284 :     bits = ((unsigned) hdr[0] << 8) + hdr[1];
      91             : 
      92         284 :     res = pgp_mpi_alloc(bits, &n);
      93         284 :     if (res < 0)
      94           0 :         return res;
      95             : 
      96         284 :     res = pullf_read_fixed(src, n->bytes, n->data);
      97         284 :     if (res < 0)
      98           4 :         pgp_mpi_free(n);
      99             :     else
     100         280 :         *mpi = n;
     101         284 :     return res;
     102             : }
     103             : 
     104             : int
     105          22 : pgp_mpi_write(PushFilter *dst, PGP_MPI *n)
     106             : {
     107             :     int         res;
     108             :     uint8       buf[2];
     109             : 
     110          22 :     buf[0] = n->bits >> 8;
     111          22 :     buf[1] = n->bits & 0xFF;
     112          22 :     res = pushf_write(dst, buf, 2);
     113          22 :     if (res >= 0)
     114          22 :         res = pushf_write(dst, n->data, n->bytes);
     115          22 :     return res;
     116             : }
     117             : 
     118             : int
     119         192 : pgp_mpi_hash(PX_MD *md, PGP_MPI *n)
     120             : {
     121             :     uint8       buf[2];
     122             : 
     123         192 :     buf[0] = n->bits >> 8;
     124         192 :     buf[1] = n->bits & 0xFF;
     125         192 :     px_md_update(md, buf, 2);
     126         192 :     px_md_update(md, n->data, n->bytes);
     127             : 
     128         192 :     return 0;
     129             : }
     130             : 
     131             : unsigned
     132          42 : pgp_mpi_cksum(unsigned cksum, PGP_MPI *n)
     133             : {
     134             :     int         i;
     135             : 
     136          42 :     cksum += n->bits >> 8;
     137          42 :     cksum += n->bits & 0xFF;
     138        4620 :     for (i = 0; i < n->bytes; i++)
     139        4578 :         cksum += n->data[i];
     140             : 
     141          42 :     return cksum & 0xFFFF;
     142             : }

Generated by: LCOV version 1.13