[u/mdw/catacomb] / key-text.c

/* -*-c-*-
 *
 * $Id: key-text.c,v 1.2 2000/06/17 11:27:20 mdw Exp $
 *
 * Key textual encoding
 *
 * (c) 1999 Straylight/Edgeware
 */

/*----- Licensing notice --------------------------------------------------* 
 *
 * This file is part of Catacomb.
 *
 * Catacomb is free software; you can redistribute it and/or modify
 * it under the terms of the GNU Library General Public License as
 * published by the Free Software Foundation; either version 2 of the
 * License, or (at your option) any later version.
 * 
 * Catacomb 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 Library General Public License for more details.
 * 
 * You should have received a copy of the GNU Library General Public
 * License along with Catacomb; if not, write to the Free
 * Software Foundation, Inc., 59 Temple Place - Suite 330, Boston,
 * MA 02111-1307, USA.
 */

/*----- Revision history --------------------------------------------------* 
 *
 * $Log: key-text.c,v $
 * Revision 1.2  2000/06/17 11:27:20  mdw
 * Use secure memory interface from MP library.
 *
 * Revision 1.1  2000/02/12 18:21:02  mdw
 * Overhaul of key management (again).
 *
 */

/*----- Header files ------------------------------------------------------*/

#include <stdlib.h>
#include <string.h>

#include <mLib/base64.h>
#include <mLib/bits.h>
#include <mLib/dstr.h>
#include <mLib/sub.h>
#include <mLib/sym.h>

#include "key-data.h"
#include "mp.h"
#include "mptext.h"

/*----- Main code ---------------------------------------------------------*/

/* --- @key_read@ --- *
 *
 * Arguments:	@const char *p@ = pointer to textual key representation
 *		@key_data *k@ = pointer to output block for key data
 *		@char **pp@ = where to store the end pointer
 *
 * Returns:	Zero if all went well, nonzero if there was a problem.
 *
 * Use:		Parses a textual key description.
 */

int key_read(const char *p, key_data *k, char **pp)
{
  unsigned e;

  /* --- Read the encoding type --- *
   *
   * The key format is `[FLAGS:]DATA'.  If there is no encoding type
   * named, assume that it's `binary' for backwards compatibility.
   */

  if (strchr(p, ':') == 0)
    e = 0;
  else {
    char *q;
    if (key_readflags(p, &q, &e, 0))
      return (-1);
    p = q + 1;
  }

  /* --- Now scan the data based on the encoding type --- */

  k->e = e;
  switch (e & KF_ENCMASK) {

    /* --- Binary encoding --- *
     *
     * Simply read out the Base64-encoded data.  Since `,' and `]' are our
     * delimeter characters, and they can't appear in Base64-encoded data, I
     * can just do a simple search to find the end of the encoded data.
     */

    case KENC_BINARY:
    case KENC_ENCRYPT: {
      dstr d = DSTR_INIT;
      base64_ctx b;
      size_t sz = strcspn(p, ",]");

      base64_init(&b);
      base64_decode(&b, p, sz, &d);
      base64_decode(&b, 0, 0, &d);
      k->u.k.k = sub_alloc(d.len);
      k->u.k.sz = d.len;
      memcpy(k->u.k.k, d.buf, d.len);
      dstr_destroy(&d);
      p += sz;
    } break;

    /* --- Multiprecision integer encoding --- *
     *
     * Multiprecision integers have a convenient reading function.
     */

    case KENC_MP: {
      char *q;
      mp *m = mp_readstring(k->e & KF_BURN ? MP_NEWSEC : MP_NEW, p, &q, 0);
      if (!m)
	return (-1);
      k->u.m = m;
      p = q;
    } break;

    /* --- Structured information encoding --- *
     *
     * The format for structured key data is `[NAME=KEY,...]', where the
     * brackets are part of the syntax.  Structured keys have no flags apart
     * from the encoding.
     *
     * The binary encoding only allows names up to 255 bytes long.  Check for
     * this here.
     */

    case KENC_STRUCT: {
      dstr d = DSTR_INIT;
      char *q;

      /* --- Read the opening bracket --- */

      k->e &= KF_ENCMASK;
      if (*p != '[')
	return (-1);
      p++;
      sym_create(&k->u.s);

      /* --- Read named key subparts --- */

      for (;;) {
	size_t sz;
	key_struct *ks;

	/* --- Stop if there's a close-bracket --- *
	 *
	 * This allows `[]' to be an empty structured key, which is good.  It
	 * also makes `[foo=enc:bar,]' legal, and that's less good but I can
	 * live with it.
	 */

	if (*p == ']')
	  break;

	/* --- Read the name out and check the length --- */

	if ((q = strchr(p, '=')) == 0)
	  goto fail;
	sz = q - p;
	if (sz >= 256)
	  goto fail;
	DRESET(&d);
	DPUTM(&d, p, sz);
	DPUTZ(&d);

	/* --- Add an appropriate block to the key table --- *
	 *
	 * Simply destroy old data if there's already a match.
	 */

	{
	  unsigned f;
	  ks = sym_find(&k->u.s, d.buf, d.len + 1, sizeof(*ks), &f);
	  if (f)
	    key_destroy(&ks->k);
	}

	/* --- Read the key data for the subkey --- */

	if (key_read(q + 1, &ks->k, &q)) {
	  sym_remove(&k->u.s, ks);
	  goto fail;
	}
	p = q;

	/* --- Read the comma or close-bracket --- */

	if (*p == ']')
	  break;
	else if (*p == ',')
	  p++;
	else
	  goto fail;
      }

      /* --- Step past the close bracket --- */

      p++;
      dstr_destroy(&d);
      break;

      /* --- Tidy up after a failure --- */

    fail:
      dstr_destroy(&d);
      key_destroy(k);
      return (-1);
    } break;

    /* --- Anything else is unknown --- */

    default:
      return (-1);
  }

  /* --- Return the end pointer --- */

  if (pp)
    *pp = (char *)p;
  return (0);
}

/* --- @key_write@ --- *
 *
 * Arguments:	@key_data *k@ = pointer to key data
 *		@dstr *d@ = destination string to write on
 *		@const key_filter *kf@ = pointer to key selection block
 *
 * Returns:	Nonzero if an item was actually written.
 *
 * Use:		Writes a key in a textual encoding.
 */
 
int key_write(key_data *k, dstr *d, const key_filter *kf)
{
  int rc = 0;
  if (!KEY_MATCH(k, kf))
    return (0);
  switch (k->e & KF_ENCMASK) {
    case KENC_BINARY:
    case KENC_ENCRYPT: {
      base64_ctx b;

      if ((k->e & KF_ENCMASK) == KENC_BINARY)
	key_writeflags(k->e, d);
      else
	DPUTS(d, "encrypt,secret");
      DPUTC(d, ':');
      base64_init(&b);
      b.indent = "";
      b.maxline = 0;
      base64_encode(&b, k->u.k.k, k->u.k.sz, d);
      base64_encode(&b, 0, 0, d);
      rc = 1;
    } break;
    case KENC_MP:
      key_writeflags(k->e, d);
      DPUTC(d, ':');
      mp_writedstr(k->u.m, d, 10);
      rc = 1;
      break;
    case KENC_STRUCT: {
      sym_iter i;
      key_struct *ks;
      char del = 0;
      size_t n = d->len;

      DPUTS(d, "struct:[");
      for (sym_mkiter(&i, &k->u.s); (ks = sym_next(&i)) != 0; ) {
	size_t o = d->len;
	if (del)
	  DPUTC(d, del);
	DPUTS(d, SYM_NAME(ks));
	DPUTC(d, '=');
	if (!key_write(&ks->k, d, kf))
	  d->len = o;
	else {
	  del = ',';
	  rc = 1;
	}
      }
      if (!rc)
	d->len = n;
      else
	DPUTC(d, ']');
    } break;
  }
  DPUTZ(d);

  return (rc);
}

/*----- That's all, folks -------------------------------------------------*/
Commit	Line	Data
052b36d0	1	/* --c--
052b36d0	2	*
99163693	3	* $Id: key-text.c,v 1.2 2000/06/17 11:27:20 mdw Exp $
052b36d0	4	*
	5	* Key textual encoding
	6	*
	7	* (c) 1999 Straylight/Edgeware
	8	*/
	9
	10	/----- Licensing notice --------------------------------------------------
	11	*
	12	* This file is part of Catacomb.
	13	*
	14	* Catacomb is free software; you can redistribute it and/or modify
	15	* it under the terms of the GNU Library General Public License as
	16	* published by the Free Software Foundation; either version 2 of the
	17	* License, or (at your option) any later version.
	18	*
	19	* Catacomb is distributed in the hope that it will be useful,
	20	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	21	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	22	* GNU Library General Public License for more details.
	23	*
	24	* You should have received a copy of the GNU Library General Public
	25	* License along with Catacomb; if not, write to the Free
	26	* Software Foundation, Inc., 59 Temple Place - Suite 330, Boston,
	27	* MA 02111-1307, USA.
	28	*/
	29
	30	/----- Revision history --------------------------------------------------
	31	*
	32	* $Log: key-text.c,v $
99163693	33	* Revision 1.2 2000/06/17 11:27:20 mdw
	34	* Use secure memory interface from MP library.
	35	*
052b36d0	36	* Revision 1.1 2000/02/12 18:21:02 mdw
	37	* Overhaul of key management (again).
	38	*
	39	*/
	40
	41	/----- Header files ------------------------------------------------------/
	42
	43	#include <stdlib.h>
	44	#include <string.h>
	45
	46	#include <mLib/base64.h>
	47	#include <mLib/bits.h>
	48	#include <mLib/dstr.h>
	49	#include <mLib/sub.h>
	50	#include <mLib/sym.h>
	51
	52	#include "key-data.h"
	53	#include "mp.h"
	54	#include "mptext.h"
	55
	56	/----- Main code ---------------------------------------------------------/
	57
	58	/* --- @key_read@ --- *
	59	*
	60	* Arguments: @const char *p@ = pointer to textual key representation
	61	* @key_data *k@ = pointer to output block for key data
	62	* @char **pp@ = where to store the end pointer
	63	*
	64	* Returns: Zero if all went well, nonzero if there was a problem.
	65	*
	66	* Use: Parses a textual key description.
	67	*/
	68
	69	int key_read(const char p, key_data k, char **pp)
	70	{
	71	unsigned e;
	72
	73	/* --- Read the encoding type --- *
	74	*
	75	* The key format is `[FLAGS:]DATA'. If there is no encoding type
	76	* named, assume that it's `binary' for backwards compatibility.
	77	*/
	78
	79	if (strchr(p, ':') == 0)
	80	e = 0;
	81	else {
	82	char *q;
	83	if (key_readflags(p, &q, &e, 0))
	84	return (-1);
	85	p = q + 1;
	86	}
	87
	88	/* --- Now scan the data based on the encoding type --- */
	89
	90	k->e = e;
	91	switch (e & KF_ENCMASK) {
	92
	93	/* --- Binary encoding --- *
	94	*
	95	* Simply read out the Base64-encoded data. Since `,' and `]' are our
	96	* delimeter characters, and they can't appear in Base64-encoded data, I
	97	* can just do a simple search to find the end of the encoded data.
	98	*/
	99
100	case KENC_BINARY:
101	case KENC_ENCRYPT: {
102	dstr d = DSTR_INIT;
103	base64_ctx b;
104	size_t sz = strcspn(p, ",]");
105
106	base64_init(&b);
107	base64_decode(&b, p, sz, &d);
108	base64_decode(&b, 0, 0, &d);
109	k->u.k.k = sub_alloc(d.len);
110	k->u.k.sz = d.len;
111	memcpy(k->u.k.k, d.buf, d.len);
112	dstr_destroy(&d);
113	p += sz;
114	} break;
115
116	/* --- Multiprecision integer encoding --- *
117	*
118	* Multiprecision integers have a convenient reading function.
119	*/
120
121	case KENC_MP: {
122	char *q;
99163693	123	mp *m = mp_readstring(k->e & KF_BURN ? MP_NEWSEC : MP_NEW, p, &q, 0);
052b36d0	124	if (!m)
052b36d0	125	return (-1);
052b36d0	126	k->u.m = m;
	127	p = q;
	128	} break;
	129
	130	/* --- Structured information encoding --- *
	131	*
	132	* The format for structured key data is `[NAME=KEY,...]', where the
	133	* brackets are part of the syntax. Structured keys have no flags apart
	134	* from the encoding.
	135	*
	136	* The binary encoding only allows names up to 255 bytes long. Check for
	137	* this here.
	138	*/
	139
	140	case KENC_STRUCT: {
	141	dstr d = DSTR_INIT;
	142	char *q;
	143
	144	/* --- Read the opening bracket --- */
	145
	146	k->e &= KF_ENCMASK;
	147	if (*p != '[')
	148	return (-1);
	149	p++;
	150	sym_create(&k->u.s);
	151
	152	/* --- Read named key subparts --- */
	153
	154	for (;;) {
	155	size_t sz;
	156	key_struct *ks;
	157
	158	/* --- Stop if there's a close-bracket --- *
	159	*
	160	* This allows `[]' to be an empty structured key, which is good. It
	161	* also makes `[foo=enc:bar,]' legal, and that's less good but I can
	162	* live with it.
	163	*/
	164
	165	if (*p == ']')
	166	break;
	167
	168	/* --- Read the name out and check the length --- */
	169
	170	if ((q = strchr(p, '=')) == 0)
	171	goto fail;
	172	sz = q - p;
	173	if (sz >= 256)
	174	goto fail;
	175	DRESET(&d);
	176	DPUTM(&d, p, sz);
	177	DPUTZ(&d);
	178
	179	/* --- Add an appropriate block to the key table --- *
	180	*
	181	* Simply destroy old data if there's already a match.
	182	*/
	183
	184	{
	185	unsigned f;
	186	ks = sym_find(&k->u.s, d.buf, d.len + 1, sizeof(*ks), &f);
	187	if (f)
	188	key_destroy(&ks->k);
	189	}
190
191	/* --- Read the key data for the subkey --- */
192
193	if (key_read(q + 1, &ks->k, &q)) {
194	sym_remove(&k->u.s, ks);
195	goto fail;
196	}
197	p = q;
198
199	/* --- Read the comma or close-bracket --- */
200
201	if (*p == ']')
202	break;
203	else if (*p == ',')
204	p++;
205	else
206	goto fail;
207	}
208
209	/* --- Step past the close bracket --- */
210
211	p++;
212	dstr_destroy(&d);
213	break;
214
215	/* --- Tidy up after a failure --- */
216
217	fail:
218	dstr_destroy(&d);
219	key_destroy(k);
220	return (-1);
221	} break;
222
223	/* --- Anything else is unknown --- */
224
225	default:
226	return (-1);
227	}
228
229	/* --- Return the end pointer --- */
230
231	if (pp)
232	pp = (char )p;
233	return (0);
234	}
235
236	/* --- @key_write@ --- *
237	*
238	* Arguments: @key_data *k@ = pointer to key data
239	* @dstr *d@ = destination string to write on
240	* @const key_filter *kf@ = pointer to key selection block
241	*
242	* Returns: Nonzero if an item was actually written.
243	*
244	* Use: Writes a key in a textual encoding.
245	*/
246
247	int key_write(key_data k, dstr d, const key_filter *kf)
248	{
249	int rc = 0;
250	if (!KEY_MATCH(k, kf))
251	return (0);
252	switch (k->e & KF_ENCMASK) {
253	case KENC_BINARY:
254	case KENC_ENCRYPT: {
255	base64_ctx b;
256
257	if ((k->e & KF_ENCMASK) == KENC_BINARY)
258	key_writeflags(k->e, d);
259	else
260	DPUTS(d, "encrypt,secret");
261	DPUTC(d, ':');
262	base64_init(&b);
263	b.indent = "";
264	b.maxline = 0;
265	base64_encode(&b, k->u.k.k, k->u.k.sz, d);
266	base64_encode(&b, 0, 0, d);
267	rc = 1;
268	} break;
269	case KENC_MP:
270	key_writeflags(k->e, d);
271	DPUTC(d, ':');
272	mp_writedstr(k->u.m, d, 10);
273	rc = 1;
274	break;
275	case KENC_STRUCT: {
276	sym_iter i;
277	key_struct *ks;
278	char del = 0;
279	size_t n = d->len;
280
281	DPUTS(d, "struct:[");
282	for (sym_mkiter(&i, &k->u.s); (ks = sym_next(&i)) != 0; ) {
283	size_t o = d->len;
284	if (del)
285	DPUTC(d, del);
286	DPUTS(d, SYM_NAME(ks));
287	DPUTC(d, '=');
288	if (!key_write(&ks->k, d, kf))
289	d->len = o;
290	else {
291	del = ',';
292	rc = 1;
293	}
294	}
295	if (!rc)
296	d->len = n;
297	else
298	DPUTC(d, ']');
299	} break;
300	}
301	DPUTZ(d);
302
303	return (rc);
304	}
305
306	/----- That's all, folks -------------------------------------------------/