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          180 : pgp_mpi_alloc(int bits, PGP_MPI **mpi)
      38              : {
      39              :     PGP_MPI    *n;
      40          180 :     int         len = (bits + 7) / 8;
      41              : 
      42          180 :     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          180 :     n = palloc(sizeof(*n) + len);
      48          180 :     n->bits = bits;
      49          180 :     n->bytes = len;
      50          180 :     n->data = (uint8 *) (n) + sizeof(*n);
      51          180 :     *mpi = n;
      52          180 :     return 0;
      53              : }
      54              : 
      55              : int
      56            6 : pgp_mpi_create(uint8 *data, int bits, PGP_MPI **mpi)
      57              : {
      58              :     int         res;
      59              :     PGP_MPI    *n;
      60              : 
      61            6 :     res = pgp_mpi_alloc(bits, &n);
      62            6 :     if (res < 0)
      63            0 :         return res;
      64            6 :     memcpy(n->data, data, n->bytes);
      65            6 :     *mpi = n;
      66            6 :     return 0;
      67              : }
      68              : 
      69              : int
      70          206 : pgp_mpi_free(PGP_MPI *mpi)
      71              : {
      72          206 :     if (mpi == NULL)
      73           29 :         return 0;
      74          177 :     px_memset(mpi, 0, sizeof(*mpi) + mpi->bytes);
      75          177 :     pfree(mpi);
      76          177 :     return 0;
      77              : }
      78              : 
      79              : int
      80          149 : 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          149 :     res = pullf_read_fixed(src, 2, hdr);
      88          149 :     if (res < 0)
      89            0 :         return res;
      90          149 :     bits = ((unsigned) hdr[0] << 8) + hdr[1];
      91              : 
      92          149 :     res = pgp_mpi_alloc(bits, &n);
      93          149 :     if (res < 0)
      94            0 :         return res;
      95              : 
      96          149 :     res = pullf_read_fixed(src, n->bytes, n->data);
      97          149 :     if (res < 0)
      98            2 :         pgp_mpi_free(n);
      99              :     else
     100          147 :         *mpi = n;
     101          149 :     return res;
     102              : }
     103              : 
     104              : int
     105           11 : pgp_mpi_write(PushFilter *dst, PGP_MPI *n)
     106              : {
     107              :     int         res;
     108              :     uint8       buf[2];
     109              : 
     110           11 :     buf[0] = n->bits >> 8;
     111           11 :     buf[1] = n->bits & 0xFF;
     112           11 :     res = pushf_write(dst, buf, 2);
     113           11 :     if (res >= 0)
     114           11 :         res = pushf_write(dst, n->data, n->bytes);
     115           11 :     return res;
     116              : }
     117              : 
     118              : int
     119           98 : pgp_mpi_hash(PX_MD *md, PGP_MPI *n)
     120              : {
     121              :     uint8       buf[2];
     122              : 
     123           98 :     buf[0] = n->bits >> 8;
     124           98 :     buf[1] = n->bits & 0xFF;
     125           98 :     px_md_update(md, buf, 2);
     126           98 :     px_md_update(md, n->data, n->bytes);
     127              : 
     128           98 :     return 0;
     129              : }
     130              : 
     131              : unsigned
     132           25 : pgp_mpi_cksum(unsigned cksum, PGP_MPI *n)
     133              : {
     134              :     int         i;
     135              : 
     136           25 :     cksum += n->bits >> 8;
     137           25 :     cksum += n->bits & 0xFF;
     138         2954 :     for (i = 0; i < n->bytes; i++)
     139         2929 :         cksum += n->data[i];
     140              : 
     141           25 :     return cksum & 0xFFFF;
     142              : }