key.h

/*
    This file is part of Pretty Curved Privacy (pcp1).

    Copyright (C) 2013-2014 T.v.Dein.

    This program is free software: you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation, either version 3 of the License, or
    (at your option) any later version.

    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.

    You should have received a copy of the GNU General Public License
    along with this program.  If not, see <http://www.gnu.org/licenses/>.

    You can contact me by mail: <tom AT vondein DOT org>.
*/


#ifndef _HAVE_PCP_KEYPAIR_H
#define _HAVE_PCP_KEYPAIR_H

#include <sodium.h>
#include <string.h>
#include <stdio.h>
#include <time.h>

#include "defines.h"
#include "platform.h"
#include "mem.h"
#include "mac.h"
#include "randomart.h"
#include "version.h"
#include "z85.h"
#include "uthash.h"
#include "jenhash.h"
#include "scrypt.h"
#include "keysig.h"


struct _pcp_key_t {
  byte masterpub[32];    
  byte mastersecret[64]; 
  byte pub[32];          
  byte secret[32];       
  byte edpub[32];        
  byte edsecret[64];     
  byte nonce[24];        
  byte encrypted[176];   
  char owner[255];       
  char mail[255];        
  char id[17];           
  uint8_t type;          
  uint64_t ctime;        
  uint32_t version;      
  uint32_t serial;       
  UT_hash_handle hh;
};

typedef struct _pcp_key_t pcp_key_t;

struct _pcp_pubkey_t {
  byte masterpub[32];    
  byte sigpub[32];       
  byte pub[32];          
  byte edpub[32];        
  char owner[255];       
  char mail[255];        
  char id[17];           
  uint8_t type;          
  uint64_t ctime;        
  uint32_t version;      
  uint32_t serial;       
  uint8_t valid;         
  byte signature[crypto_generichash_BYTES_MAX + crypto_sign_BYTES]; 
  UT_hash_handle hh;
};

typedef struct _pcp_pubkey_t pcp_pubkey_t;


/*  the PBP public key format */
/*  keys.mp+keys.cp+keys.sp+keys.name */
struct _pbp_pubkey_t {
  byte sigpub[crypto_sign_PUBLICKEYBYTES];
  byte edpub[crypto_sign_PUBLICKEYBYTES];
  byte pub[crypto_box_PUBLICKEYBYTES];
  char iso_ctime[32];
  char iso_expire[32];
  char name[1024];
};

typedef struct _pbp_pubkey_t pbp_pubkey_t;

struct _pcp_rec_t {
  size_t ciphersize; 
  byte *cipher;      
  pcp_key_t *secret; 
  pcp_pubkey_t *pub; 
};

typedef struct _pcp_rec_t pcp_rec_t;

#define PCP_RAW_KEYSIZE    sizeof(pcp_key_t)    - sizeof(UT_hash_handle)
#define PCP_RAW_PUBKEYSIZE sizeof(pcp_pubkey_t) - sizeof(UT_hash_handle)


pcp_key_t *pcpkey_new ();

void pcp_keypairs(byte *msk, byte *mpk, byte *csk, byte *cpk, byte *esk, byte *epk);

char *pcppubkey_get_art(pcp_pubkey_t *k);

char *pcpkey_get_art(pcp_key_t *k);

pcp_key_t *pcpkey_encrypt(pcp_key_t *key, char *passphrase);

pcp_key_t *pcpkey_decrypt(pcp_key_t *key, char *passphrase);

pcp_pubkey_t *pcpkey_pub_from_secret(pcp_key_t *key);


char *pcp_getkeyid(pcp_key_t *k);


char *pcp_getpubkeyid(pcp_pubkey_t *k);

unsigned char *pcppubkey_getchecksum(pcp_pubkey_t *k);

unsigned char *pcpkey_getchecksum(pcp_key_t *k);


pcp_key_t *pcpkey_exists(char *id);

pcp_pubkey_t *pcppubkey_exists(char *id);

pcp_key_t * key2be(pcp_key_t *k);
pcp_key_t *key2native(pcp_key_t *k);
pcp_pubkey_t * pubkey2be(pcp_pubkey_t *k);
pcp_pubkey_t *pubkey2native(pcp_pubkey_t *k);

unsigned char * pcp_gennonce();

/*  use scrypt() to create a key from a passphrase and a nonce
    FIXME: use pure scrypt() instead.
*/
unsigned char *pcp_derivekey(char *passphrase, unsigned char *nonce);

/* FIXME: abandon and use Buffer instead */
void pcp_seckeyblob(void *blob, pcp_key_t *k);
void pcp_pubkeyblob(void *blob, pcp_pubkey_t *k);
void *pcp_keyblob(void *k, int type); /*  allocates blob */

int pcp_sanitycheck_pub(pcp_pubkey_t *key);

int pcp_sanitycheck_key(pcp_key_t *key);

void pcp_dumpkey(pcp_key_t *k);

void pcp_dumppubkey(pcp_pubkey_t *k);


#endif /*  _HAVE_PCP_KEYPAIR_H */