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