binbrain · Mar 9, 2012
diff --git a/‎Makefile.am
+12 b/‎Makefile.am
+12
diff --git a/‎configure.ac
+34 b/‎configure.ac
+34
diff --git a/‎src/_apg.c
+760 b/‎src/_apg.c
+760
diff --git a/‎src/apg.c
+50 b/‎src/apg.c
+50
diff --git a/‎src/apg.h
+34 b/‎src/apg.h
+34
diff --git a/‎src/bloom.c
+479 b/‎src/bloom.c
+479
diff --git a/‎src/bloom.h
+91 b/‎src/bloom.h
+91
diff --git a/‎src/cast/cast.c
+239 b/‎src/cast/cast.c
+239
diff --git a/‎src/cast/cast.h
+24 b/‎src/cast/cast.h
+24
diff --git a/‎src/cast/cast_sboxes.h
+543 b/‎src/cast/cast_sboxes.h
+543
diff --git a/‎src/convert.c
+407 b/‎src/convert.c
+407
diff --git a/‎src/convert.h
+43 b/‎src/convert.h
+43
diff --git a/‎src/errors.c
+131 b/‎src/errors.c
+131
diff --git a/‎src/errs.h
+40 b/‎src/errs.h
+40
diff --git a/‎src/main.c
+11 b/‎src/main.c
+11
diff --git a/‎src/owntypes.h
+44 b/‎src/owntypes.h
+44
diff --git a/‎src/pronpass.c
+2,302 b/‎src/pronpass.c
+2,302
diff --git a/‎src/pronpass.h
+84 b/‎src/pronpass.h
+84
diff --git a/‎src/randpass.c
+163 b/‎src/randpass.c
+163
diff --git a/‎src/randpass.h
+62 b/‎src/randpass.h
+62
diff --git a/‎src/restrict.c
+273 b/‎src/restrict.c
+273
diff --git a/‎src/restrict.h
+45 b/‎src/restrict.h
+45
diff --git a/‎src/rnd.c
+214 b/‎src/rnd.c
+214
diff --git a/‎src/rnd.h
+55 b/‎src/rnd.h
+55
diff --git a/‎src/sha/sha.c
+297 b/‎src/sha/sha.c
+297
diff --git a/‎src/sha/sha.h
+39 b/‎src/sha/sha.h
+39
diff --git a/‎src/smbl.h
+51 b/‎src/smbl.h
+51
@@ -0,0 +1,12 @@
+ACLOCAL_AMFLAGS = -I m4 ${ACLOCAL_FLAGS}
+AM_CFLAGS = -c -D_GNU_SOURCE -O2 -ggdb3 --std=gnu99 -fPIC $(CFLAGS) -ggdb
+lib_LTLIBRARIES = libapg.la
+libapg_la_SOURCES =     src/bloom.c src/convert.c src/apg.h src/apg.c\
+			src/convert.h src/errors.c src/errs.h src/owntypes.h\
+			src/pronpass.c\
+			src/pronpass.h src/randpass.c src/randpass.h\
+			src/restrict.c src/restrict.h src/rnd.c src/rnd.h smbl.h\
+			src/cast/cast.h src/cast/cast_sboxes.h src/sha/sha.c\
+			src/sha/sha.h src/cast/cast.c\
+libapg_la_LDFLAGS= -lcrypto
+include_HEADERS = src/apg.h
@@ -0,0 +1,34 @@
+#                                               -*- Autoconf -*-
+# Process this file with autoconf to produce a configure script.
+
+AC_PREREQ([2.68])
+AC_INIT([libapg], [0.1], [http://git.hub])
+AC_CONFIG_HEADERS([config.h])
+AM_INIT_AUTOMAKE([-Wall])
+AC_PROG_LIBTOOL
+AC_CONFIG_MACRO_DIR([m4])
+
+# Checks for programs.
+AC_PROG_AWK
+AC_PROG_CC
+AC_PROG_INSTALL
+
+# Checks for libraries.
+# FIXME: Replace `main' with a function in `-lcrypt':
+AC_CHECK_LIB([crypt], [main])
+# FIXME: Replace `main' with a function in `-lcrypto':
+AC_CHECK_LIB([crypto], [main])
+# FIXME: Replace `main' with a function in `-lm':
+AC_CHECK_LIB([m], [main])
+
+# Checks for header files.
+AC_CHECK_HEADERS([arpa/inet.h netinet/in.h stdlib.h string.h strings.h sys/socket.h sys/time.h syslog.h unistd.h])
+
+# Checks for typedefs, structures, and compiler characteristics.
+AC_TYPE_SIZE_T
+
+# Checks for library functions.
+AC_CHECK_FUNCS([getpass gettimeofday inet_ntoa memset strchr strerror])
+
+AC_CONFIG_FILES([Makefile])
+AC_OUTPUT
@@ -0,0 +1,50 @@
+#include <stdio.h>
+#include <time.h>
+
+#include "apg.h"
+#include "pronpass.h"
+#include "rnd.h"
+#include "restrict.h"
+
+#define S_NB    0x01 /* Numeric */
+#define S_SS    0x02 /* Special */
+#define S_CL    0x04 /* Capital */
+#define S_SL    0x08 /* Small   */
+
+APGPassword * 
+apg_password(APGPasswordProps *props, APGMode *mode)
+{
+}
+
+void
+test_apg() {
+    APGPassword* apgpasswd;
+    //char * pstr;
+    //char * pho;  
+    //time_t t;
+    int filter_check_result = 0;
+
+    //t = time(NULL);
+    //x917_setseed((UINT32)time(NULL), FALSE);
+    apgpasswd->password = (char *)calloc(1, (size_t)(10+1));
+    apgpasswd->phonetic = (char *)calloc(1, (size_t)(10*18));
+    //apgpasswd->password = calloc(max_len, sizeof(char *));
+    //apgpasswd->phonetic = calloc(max_len, sizeof( (char *) * 18));
+
+    do {
+    
+
+        printf("password creation\n");
+        //gen_pron_pass(apgpasswd->password, apgpasswd->phonetic, 5, 10, S_NB|S_SS|S_CL);
+        //printf("passwd is %s phonetic  %s\n\n", apgpasswd->password, apgpasswd->phonetic);
+        //filter_check_result = filter_check_pass(apgpasswd->password, S_NB|S_SS|S_CL);
+        //printf("filter %i\n", filter_check_result);
+
+        //free((void*)apgpasswd->password);
+        //free((void*)apgpasswd->phonetic);
+        filter_check_result++;
+
+    } while(filter_check_result < 4);
+    
+}
+
@@ -0,0 +1,34 @@
+
+typedef struct _APGPassword APGPassword;
+typedef struct _APGPasswords APGPasswords;
+typedef struct _APGPasswordProps APGPasswordProps;
+typedef enum _APGMode APGMode;
+
+struct _APGPasswords {
+    /* array of generated passwords */
+    //GList * passwords;
+    int nothing;
+};
+
+struct _APGPassword {
+    /* should be in secure memory */
+    char * phonetic;
+    char * password;
+};
+
+enum APGMode {
+    USE_SYMBOLS = 0x1,
+    USE_NUMBERIC = 0x2,
+    USED_MIXED_CASE = 0x4
+};
+
+struct _APGPasswordProps {
+    unsigned short min_pass_len;
+    unsigned short max_pass_len;
+    /* cl_seed random seed */
+};
+
+APGPassword  * apg_password(APGPasswordProps *props, APGMode *mode);
+APGPasswords * agg_password_list(APGPasswordProps *props, APGMode *mode);
+
+void test_apg();
@@ -0,0 +1,91 @@
+/*
+** Copyright (c) 2001, 2002, 2003
+** Adel I. Mirzazhanov. All rights reserved
+**
+** Redistribution and use in source and binary forms, with or without
+** modification, are permitted provided that the following conditions
+** are met:
+** 
+**     1.Redistributions of source code must retain the above copyright notice,
+**       this list of conditions and the following disclaimer. 
+**     2.Redistributions in binary form must reproduce the above copyright
+**       notice, this list of conditions and the following disclaimer in the
+**       documentation and/or other materials provided with the distribution. 
+**     3.The name of the author may not be used to endorse or promote products
+**       derived from this software without specific prior written permission. 
+** 		  
+** THIS SOFTWARE IS PROVIDED BY THE AUTHOR  ``AS IS'' AND ANY EXPRESS
+** OR IMPLIED WARRANTIES, INCLUDING,  BUT NOT LIMITED TO, THE IMPLIED
+** WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+** ARE DISCLAIMED.  IN  NO  EVENT  SHALL THE AUTHOR BE LIABLE FOR ANY
+** DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+** DAMAGES (INCLUDING, BUT NOT LIMITED TO,  PROCUREMENT OF SUBSTITUTE
+** GOODS OR SERVICES;  LOSS OF USE,  DATA,  OR  PROFITS;  OR BUSINESS
+** INTERRUPTION)  HOWEVER  CAUSED  AND  ON  ANY  THEORY OF LIABILITY,
+** WHETHER  IN  CONTRACT,   STRICT   LIABILITY,  OR  TORT  (INCLUDING
+** NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+** SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*/
+
+
+
+/*
+** Header file  for bloom filter algorithm implementation
+*/
+#ifndef APG_BLOOM_H
+#define APG_BLOOM_H 1
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#if !defined(WIN32) && !defined(_WIN32) && !defined(__WIN32) && !defined(__WIN32__)
+#include <strings.h>
+#endif
+#include <math.h>
+
+#include "sha/sha.h"
+
+#define APGBF_ID      "APGBF"
+#define APGBF_VERSION "110" /* Version 1.1.0 */
+
+/* Bloom filter modes flags */
+#define BF_CASE_INSENSITIVE 0x01
+#define BF_RESERVED1        0x02
+#define BF_RESERVED2        0x04
+#define BF_RESERVED3        0x08
+#define BF_RESERVED4        0x10
+#define BF_RESERVED5        0x20
+#define BF_RESERVED6        0x40
+#define BF_RESERVED7        0x80
+
+#define APGBFHDRSIZE      13
+
+#define TRUE              1
+#define FALSE             0
+
+#define MAX_DICT_STRLEN   255
+#define H_NUM   5
+
+typedef unsigned long int      h_val; /* should be 32-bit */
+typedef unsigned short int     flag;
+typedef unsigned char          f_mode;
+
+struct apg_bf_hdr {
+  char id[5];           /* filter ID      */
+  char version[3];      /* filter version */
+  unsigned long int fs; /* filter size    */
+  f_mode mode;          /* filter flags   */
+};
+
+extern int insert_word(char *word, FILE *file, h_val filter_size, f_mode mode);
+extern int check_word(char *word, FILE *file, h_val filter_size, f_mode mode);
+extern FILE * create_filter(char * f_name, unsigned long int n_words, f_mode mode); 
+extern FILE * open_filter(char * f_name, const char *mode); 
+extern int close_filter(FILE *f_dsk);
+extern h_val get_filtersize(FILE *f); 
+extern f_mode get_filtermode(FILE *f); 
+extern h_val count_words(FILE *dict_file);
+#ifdef APGBFM
+extern int print_flt_info(FILE * filter);
+#endif /* APGBFM */
+#endif /* APG_BLOOM_H */
@@ -0,0 +1,239 @@
+/*
+ *	CAST-128 in C
+ *	Written by Steve Reid <sreid@sea-to-sky.net>
+ *	100% Public Domain - no warranty
+ *	Released 1997.10.11
+ */
+
+#include "cast.h"
+#include "cast_sboxes.h"
+
+/* Macros to access 8-bit bytes out of a 32-bit word */
+#define U8a(x) ( (u8) (x>>24) )
+#define U8b(x) ( (u8) ((x>>16)&255) )
+#define U8c(x) ( (u8) ((x>>8)&255) )
+#define U8d(x) ( (u8) ((x)&255) )
+
+/* Circular left shift */
+#define ROL(x, n) ( ((x)<<(n)) | ((x)>>(32-(n))) )
+
+/* CAST-128 uses three different round functions */
+#define F1(l, r, i) \
+	t = ROL(key->xkey[i] + r, key->xkey[i+16]); \
+	l ^= ((cast_sbox1[U8a(t)] ^ cast_sbox2[U8b(t)]) - \
+	 cast_sbox3[U8c(t)]) + cast_sbox4[U8d(t)];
+#define F2(l, r, i) \
+	t = ROL(key->xkey[i] ^ r, key->xkey[i+16]); \
+	l ^= ((cast_sbox1[U8a(t)] - cast_sbox2[U8b(t)]) + \
+	 cast_sbox3[U8c(t)]) ^ cast_sbox4[U8d(t)];
+#define F3(l, r, i) \
+	t = ROL(key->xkey[i] - r, key->xkey[i+16]); \
+	l ^= ((cast_sbox1[U8a(t)] + cast_sbox2[U8b(t)]) ^ \
+	 cast_sbox3[U8c(t)]) - cast_sbox4[U8d(t)];
+
+
+/***** Encryption Function *****/
+
+void cast_encrypt(cast_key* key, u8* inblock, u8* outblock)
+{
+u32 t, l, r;
+
+	/* Get inblock into l,r */
+	l = ((u32)inblock[0] << 24) | ((u32)inblock[1] << 16) |
+	 ((u32)inblock[2] << 8) | (u32)inblock[3];
+	r = ((u32)inblock[4] << 24) | ((u32)inblock[5] << 16) |
+	 ((u32)inblock[6] << 8) | (u32)inblock[7];
+	/* Do the work */
+	F1(l, r,  0);
+	F2(r, l,  1);
+	F3(l, r,  2);
+	F1(r, l,  3);
+	F2(l, r,  4);
+	F3(r, l,  5);
+	F1(l, r,  6);
+	F2(r, l,  7);
+	F3(l, r,  8);
+	F1(r, l,  9);
+	F2(l, r, 10);
+	F3(r, l, 11);
+	/* Only do full 16 rounds if key length > 80 bits */
+	if (key->rounds > 12) {
+		F1(l, r, 12);
+		F2(r, l, 13);
+		F3(l, r, 14);
+		F1(r, l, 15);
+	}
+	/* Put l,r into outblock */
+	outblock[0] = U8a(r);
+	outblock[1] = U8b(r);
+	outblock[2] = U8c(r);
+	outblock[3] = U8d(r);
+	outblock[4] = U8a(l);
+	outblock[5] = U8b(l);
+	outblock[6] = U8c(l);
+	outblock[7] = U8d(l);
+	/* Wipe clean */
+	t = l = r = 0;
+}
+
+
+/***** Decryption Function *****/
+
+void cast_decrypt(cast_key* key, u8* inblock, u8* outblock)
+{
+u32 t, l, r;
+
+	/* Get inblock into l,r */
+	r = ((u32)inblock[0] << 24) | ((u32)inblock[1] << 16) |
+	 ((u32)inblock[2] << 8) | (u32)inblock[3];
+	l = ((u32)inblock[4] << 24) | ((u32)inblock[5] << 16) |
+	 ((u32)inblock[6] << 8) | (u32)inblock[7];
+	/* Do the work */
+	/* Only do full 16 rounds if key length > 80 bits */
+	if (key->rounds > 12) {
+		F1(r, l, 15);
+		F3(l, r, 14);
+		F2(r, l, 13);
+		F1(l, r, 12);
+	}
+	F3(r, l, 11);
+	F2(l, r, 10);
+	F1(r, l,  9);
+	F3(l, r,  8);
+	F2(r, l,  7);
+	F1(l, r,  6);
+	F3(r, l,  5);
+	F2(l, r,  4);
+	F1(r, l,  3);
+	F3(l, r,  2);
+	F2(r, l,  1);
+	F1(l, r,  0);
+	/* Put l,r into outblock */
+	outblock[0] = U8a(l);
+	outblock[1] = U8b(l);
+	outblock[2] = U8c(l);
+	outblock[3] = U8d(l);
+	outblock[4] = U8a(r);
+	outblock[5] = U8b(r);
+	outblock[6] = U8c(r);
+	outblock[7] = U8d(r);
+	/* Wipe clean */
+	t = l = r = 0;
+}
+
+
+/***** Key Schedual *****/
+
+void cast_setkey(cast_key* key, u8* rawkey, int keybytes)
+{
+u32 t[4], z[4], x[4];
+int i;
+
+	/* Set number of rounds to 12 or 16, depending on key length */
+	key->rounds = (keybytes <= 10 ? 12 : 16);
+
+	/* Copy key to workspace x */
+	for (i = 0; i < 4; i++) {
+		x[i] = 0;
+		if ((i*4+0) < keybytes) x[i] = (u32)rawkey[i*4+0] << 24;
+		if ((i*4+1) < keybytes) x[i] |= (u32)rawkey[i*4+1] << 16;
+		if ((i*4+2) < keybytes) x[i] |= (u32)rawkey[i*4+2] << 8;
+		if ((i*4+3) < keybytes) x[i] |= (u32)rawkey[i*4+3];
+	}
+	/* Generate 32 subkeys, four at a time */
+	for (i = 0; i < 32; i+=4) {
+		switch (i & 4) {
+		 case 0:
+			t[0] = z[0] = x[0] ^ cast_sbox5[U8b(x[3])] ^
+			 cast_sbox6[U8d(x[3])] ^ cast_sbox7[U8a(x[3])] ^
+			 cast_sbox8[U8c(x[3])] ^ cast_sbox7[U8a(x[2])];
+			t[1] = z[1] = x[2] ^ cast_sbox5[U8a(z[0])] ^
+			 cast_sbox6[U8c(z[0])] ^ cast_sbox7[U8b(z[0])] ^
+			 cast_sbox8[U8d(z[0])] ^ cast_sbox8[U8c(x[2])];
+			t[2] = z[2] = x[3] ^ cast_sbox5[U8d(z[1])] ^
+			 cast_sbox6[U8c(z[1])] ^ cast_sbox7[U8b(z[1])] ^
+			 cast_sbox8[U8a(z[1])] ^ cast_sbox5[U8b(x[2])];
+			t[3] = z[3] = x[1] ^ cast_sbox5[U8c(z[2])] ^
+			 cast_sbox6[U8b(z[2])] ^ cast_sbox7[U8d(z[2])] ^
+			 cast_sbox8[U8a(z[2])] ^ cast_sbox6[U8d(x[2])];
+			break;
+		 case 4:
+			t[0] = x[0] = z[2] ^ cast_sbox5[U8b(z[1])] ^
+			 cast_sbox6[U8d(z[1])] ^ cast_sbox7[U8a(z[1])] ^
+			 cast_sbox8[U8c(z[1])] ^ cast_sbox7[U8a(z[0])];
+			t[1] = x[1] = z[0] ^ cast_sbox5[U8a(x[0])] ^
+			 cast_sbox6[U8c(x[0])] ^ cast_sbox7[U8b(x[0])] ^
+			 cast_sbox8[U8d(x[0])] ^ cast_sbox8[U8c(z[0])];
+			t[2] = x[2] = z[1] ^ cast_sbox5[U8d(x[1])] ^
+			 cast_sbox6[U8c(x[1])] ^ cast_sbox7[U8b(x[1])] ^
+			 cast_sbox8[U8a(x[1])] ^ cast_sbox5[U8b(z[0])];
+			t[3] = x[3] = z[3] ^ cast_sbox5[U8c(x[2])] ^
+			 cast_sbox6[U8b(x[2])] ^ cast_sbox7[U8d(x[2])] ^
+			 cast_sbox8[U8a(x[2])] ^ cast_sbox6[U8d(z[0])];
+			break;
+		}
+		switch (i & 12) {
+		 case 0:
+		 case 12:
+			key->xkey[i+0] = cast_sbox5[U8a(t[2])] ^ cast_sbox6[U8b(t[2])] ^
+			 cast_sbox7[U8d(t[1])] ^ cast_sbox8[U8c(t[1])];
+			key->xkey[i+1] = cast_sbox5[U8c(t[2])] ^ cast_sbox6[U8d(t[2])] ^
+			 cast_sbox7[U8b(t[1])] ^ cast_sbox8[U8a(t[1])];
+			key->xkey[i+2] = cast_sbox5[U8a(t[3])] ^ cast_sbox6[U8b(t[3])] ^
+			 cast_sbox7[U8d(t[0])] ^ cast_sbox8[U8c(t[0])];
+			key->xkey[i+3] = cast_sbox5[U8c(t[3])] ^ cast_sbox6[U8d(t[3])] ^
+			 cast_sbox7[U8b(t[0])] ^ cast_sbox8[U8a(t[0])];
+			break;
+		 case 4:
+		 case 8:
+			key->xkey[i+0] = cast_sbox5[U8d(t[0])] ^ cast_sbox6[U8c(t[0])] ^
+			 cast_sbox7[U8a(t[3])] ^ cast_sbox8[U8b(t[3])];
+			key->xkey[i+1] = cast_sbox5[U8b(t[0])] ^ cast_sbox6[U8a(t[0])] ^
+			 cast_sbox7[U8c(t[3])] ^ cast_sbox8[U8d(t[3])];
+			key->xkey[i+2] = cast_sbox5[U8d(t[1])] ^ cast_sbox6[U8c(t[1])] ^
+			 cast_sbox7[U8a(t[2])] ^ cast_sbox8[U8b(t[2])];
+			key->xkey[i+3] = cast_sbox5[U8b(t[1])] ^ cast_sbox6[U8a(t[1])] ^
+			 cast_sbox7[U8c(t[2])] ^ cast_sbox8[U8d(t[2])];
+			break;
+		}
+		switch (i & 12) {
+		 case 0:
+			key->xkey[i+0] ^= cast_sbox5[U8c(z[0])];
+			key->xkey[i+1] ^= cast_sbox6[U8c(z[1])];
+			key->xkey[i+2] ^= cast_sbox7[U8b(z[2])];
+			key->xkey[i+3] ^= cast_sbox8[U8a(z[3])];
+			break;
+		 case 4:
+			key->xkey[i+0] ^= cast_sbox5[U8a(x[2])];
+			key->xkey[i+1] ^= cast_sbox6[U8b(x[3])];
+			key->xkey[i+2] ^= cast_sbox7[U8d(x[0])];
+			key->xkey[i+3] ^= cast_sbox8[U8d(x[1])];
+			break;
+		 case 8:
+			key->xkey[i+0] ^= cast_sbox5[U8b(z[2])];
+			key->xkey[i+1] ^= cast_sbox6[U8a(z[3])];
+			key->xkey[i+2] ^= cast_sbox7[U8c(z[0])];
+			key->xkey[i+3] ^= cast_sbox8[U8c(z[1])];
+			break;
+		 case 12:
+			key->xkey[i+0] ^= cast_sbox5[U8d(x[0])];
+			key->xkey[i+1] ^= cast_sbox6[U8d(x[1])];
+			key->xkey[i+2] ^= cast_sbox7[U8a(x[2])];
+			key->xkey[i+3] ^= cast_sbox8[U8b(x[3])];
+			break;
+		}
+		if (i >= 16) {
+			key->xkey[i+0] &= 31;
+			key->xkey[i+1] &= 31;
+			key->xkey[i+2] &= 31;
+			key->xkey[i+3] &= 31;
+		}
+	}
+	/* Wipe clean */
+	for (i = 0; i < 4; i++) {
+		t[i] = x[i] = z[i] = 0;
+	}
+}
+
+/* Made in Canada */
+
@@ -0,0 +1,24 @@
+/*
+ *	CAST-128 in C
+ *	Written by Steve Reid <sreid@sea-to-sky.net>
+ *	100% Public Domain - no warranty
+ *	Released 1997.10.11
+ */
+
+#ifndef _CAST_H_
+#define _CAST_H_
+
+typedef unsigned char u8;	/* 8-bit unsigned */
+typedef unsigned long u32;	/* 32-bit unsigned */
+
+typedef struct {
+	u32 xkey[32];	/* Key, after expansion */
+	int rounds;		/* Number of rounds to use, 12 or 16 */
+} cast_key;
+
+void cast_setkey(cast_key* key, u8* rawkey, int keybytes);
+void cast_encrypt(cast_key* key, u8* inblock, u8* outblock);
+void cast_decrypt(cast_key* key, u8* inblock, u8* outblock);
+
+#endif /* ifndef _CAST_H_ */
+
@@ -0,0 +1,43 @@
+/*
+** Copyright (c) 1999, 2000, 2001, 2002, 2003
+** Adel I. Mirzazhanov. All rights reserved
+**
+** Redistribution and use in source and binary forms, with or without
+** modification, are permitted provided that the following conditions
+** are met:
+** 
+**     1.Redistributions of source code must retain the above copyright notice,
+**       this list of conditions and the following disclaimer. 
+**     2.Redistributions in binary form must reproduce the above copyright
+**       notice, this list of conditions and the following disclaimer in the
+**       documentation and/or other materials provided with the distribution. 
+**     3.The name of the author may not be used to endorse or promote products
+**       derived from this software without specific prior written permission. 
+** 		  
+** THIS SOFTWARE IS PROVIDED BY THE AUTHOR  ``AS IS'' AND ANY EXPRESS
+** OR IMPLIED WARRANTIES, INCLUDING,  BUT NOT LIMITED TO, THE IMPLIED
+** WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+** ARE DISCLAIMED.  IN  NO  EVENT  SHALL THE AUTHOR BE LIABLE FOR ANY
+** DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+** DAMAGES (INCLUDING, BUT NOT LIMITED TO,  PROCUREMENT OF SUBSTITUTE
+** GOODS OR SERVICES;  LOSS OF USE,  DATA,  OR  PROFITS;  OR BUSINESS
+** INTERRUPTION)  HOWEVER  CAUSED  AND  ON  ANY  THEORY OF LIABILITY,
+** WHETHER  IN  CONTRACT,   STRICT   LIABILITY,  OR  TORT  (INCLUDING
+** NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+** SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*/
+
+#ifndef APG_CONVERT_H
+#define APG_CONVERT_H	1
+
+void decapitalize (char *word);
+
+#ifndef APGBFM
+void capitalize (char *syllable);
+void numerize (char *syllable);
+void specialize (char *syllable);
+void symb2name(char * syllable, char * h_syllable);
+char* spell_word(char * word, char * spelled_word);
+#endif /* APGBFM */
+
+#endif /* APG_CONVERT_H */
@@ -0,0 +1,131 @@
+/*
+** Copyright (c) 1999, 2000, 2001, 2002, 2003
+** Adel I. Mirzazhanov. All rights reserved
+**
+** Redistribution and use in source and binary forms, with or without
+** modification, are permitted provided that the following conditions
+** are met:
+** 
+**     1.Redistributions of source code must retain the above copyright notice,
+**       this list of conditions and the following disclaimer. 
+**     2.Redistributions in binary form must reproduce the above copyright
+**       notice, this list of conditions and the following disclaimer in the
+**       documentation and/or other materials provided with the distribution. 
+**     3.The name of the author may not be used to endorse or promote products
+**       derived from this software without specific prior written permission. 
+** 		  
+** THIS SOFTWARE IS PROVIDED BY THE AUTHOR  ``AS IS'' AND ANY EXPRESS
+** OR IMPLIED WARRANTIES, INCLUDING,  BUT NOT LIMITED TO, THE IMPLIED
+** WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+** ARE DISCLAIMED.  IN  NO  EVENT  SHALL THE AUTHOR BE LIABLE FOR ANY
+** DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+** DAMAGES (INCLUDING, BUT NOT LIMITED TO,  PROCUREMENT OF SUBSTITUTE
+** GOODS OR SERVICES;  LOSS OF USE,  DATA,  OR  PROFITS;  OR BUSINESS
+** INTERRUPTION)  HOWEVER  CAUSED  AND  ON  ANY  THEORY OF LIABILITY,
+** WHETHER  IN  CONTRACT,   STRICT   LIABILITY,  OR  TORT  (INCLUDING
+** NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+** SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*/
+
+#include <stdio.h>
+#include <string.h>
+#include <unistd.h>
+#include <stdlib.h>
+#include "errs.h"
+
+#ifdef CLISERV
+#  include <syslog.h>
+#endif
+
+/*
+** err_sys() - routine that handles non-fatal system errors
+** like calloc, open, etc.
+** INPUT:
+**   const char * - error name.
+** OUTPUT:
+**   prints error to stderr.
+** NOTES:
+**   none.
+*/
+void
+err_sys(const char *string)
+{
+
+#ifndef CLISERV
+ perror(string);
+#else
+ syslog (LOG_DEBUG, "%s: %s",string, (char *)strerror(errno));
+#endif
+}
+
+/*
+** err_sus_fatal() - routine that handles fatal system errors
+** like calloc, open, etc.
+** INPUT:
+**   const char * - error name.
+** OUTPUT:
+**   prints error to stderr and then exit.
+** NOTES:
+**   none.
+*/
+void
+err_sys_fatal(const char *string)
+{
+
+#ifndef CLISERV
+ perror(string);
+#else
+ syslog (LOG_DEBUG, "%s: %s", string, (char *)strerror(errno));
+ closelog();
+ close(0);
+#endif
+ exit (-1);
+}
+
+/*
+** err_app() - routine that handles non-fatal application errors.
+** INPUT:
+**   const char * - error name.
+**   const char * - error description.
+** OUTPUT:
+**   prints error to stderr.
+** NOTES:
+**   none.
+*/
+void
+err_app(const char *string, const char * err)
+{
+#ifndef CLISERV
+ fprintf (stderr, "%s: ", string);
+ fprintf (stderr, "%s\n", err);
+ fflush (stderr);
+#else
+ syslog (LOG_DEBUG, "%s: %s",string, err);
+#endif
+}
+
+/*
+** err_app_fatal() - routine that handles fatal application errors.
+** INPUT:
+**   const char * - error name.
+**   const char * - error description.
+** OUTPUT:
+**   prints error to stderr and then exit.
+** NOTES:
+**   none.
+*/
+void
+err_app_fatal(const char *string, const char *err)
+{
+
+#ifndef CLISERV
+ fprintf (stderr, "%s: ", string);
+ fprintf (stderr, "%s\n", err);
+ fflush (stderr);
+#else
+ syslog (LOG_DEBUG, "%s: %s",string, err);
+ closelog();
+ close(0);
+#endif
+ exit (-1);
+}
@@ -0,0 +1,40 @@
+/*
+** Copyright (c) 1999, 2000, 2001, 2002, 2003
+** Adel I. Mirzazhanov. All rights reserved
+**
+** Redistribution and use in source and binary forms, with or without
+** modification, are permitted provided that the following conditions
+** are met:
+** 
+**     1.Redistributions of source code must retain the above copyright notice,
+**       this list of conditions and the following disclaimer. 
+**     2.Redistributions in binary form must reproduce the above copyright
+**       notice, this list of conditions and the following disclaimer in the
+**       documentation and/or other materials provided with the distribution. 
+**     3.The name of the author may not be used to endorse or promote products
+**       derived from this software without specific prior written permission. 
+** 		  
+** THIS SOFTWARE IS PROVIDED BY THE AUTHOR  ``AS IS'' AND ANY EXPRESS
+** OR IMPLIED WARRANTIES, INCLUDING,  BUT NOT LIMITED TO, THE IMPLIED
+** WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+** ARE DISCLAIMED.  IN  NO  EVENT  SHALL THE AUTHOR BE LIABLE FOR ANY
+** DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+** DAMAGES (INCLUDING, BUT NOT LIMITED TO,  PROCUREMENT OF SUBSTITUTE
+** GOODS OR SERVICES;  LOSS OF USE,  DATA,  OR  PROFITS;  OR BUSINESS
+** INTERRUPTION)  HOWEVER  CAUSED  AND  ON  ANY  THEORY OF LIABILITY,
+** WHETHER  IN  CONTRACT,   STRICT   LIABILITY,  OR  TORT  (INCLUDING
+** NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+** SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*/
+
+#ifndef APG_ERRS_H
+#define APG_ERRS_H	1
+
+#include <errno.h>
+
+extern void err_sys(const char *string);
+extern void err_sys_fatal(const char *string);
+extern void err_app(const char *string, const char *err);
+extern void err_app_fatal(const char *string, const char *err);
+
+#endif /* APG_ERRS_H */
@@ -0,0 +1,11 @@
+#include <stdio.h>
+#include <apg.h>
+
+
+//after installing library
+//compile this for simple test
+//gcc -I/usr/local/include/ -L/usr/local/lib -o out main.c -lapg
+int main(void) {
+   test_apg();
+}
+    
@@ -0,0 +1,44 @@
+/*
+** Copyright (c) 1999, 2000, 2001, 2002, 2003
+** Adel I. Mirzazhanov. All rights reserved
+**
+** Redistribution and use in source and binary forms, with or without
+** modification, are permitted provided that the following conditions
+** are met:
+** 
+**     1.Redistributions of source code must retain the above copyright notice,
+**       this list of conditions and the following disclaimer. 
+**     2.Redistributions in binary form must reproduce the above copyright
+**       notice, this list of conditions and the following disclaimer in the
+**       documentation and/or other materials provided with the distribution. 
+**     3.The name of the author may not be used to endorse or promote products
+**       derived from this software without specific prior written permission. 
+** 		  
+** THIS SOFTWARE IS PROVIDED BY THE AUTHOR  ``AS IS'' AND ANY EXPRESS
+** OR IMPLIED WARRANTIES, INCLUDING,  BUT NOT LIMITED TO, THE IMPLIED
+** WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+** ARE DISCLAIMED.  IN  NO  EVENT  SHALL THE AUTHOR BE LIABLE FOR ANY
+** DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+** DAMAGES (INCLUDING, BUT NOT LIMITED TO,  PROCUREMENT OF SUBSTITUTE
+** GOODS OR SERVICES;  LOSS OF USE,  DATA,  OR  PROFITS;  OR BUSINESS
+** INTERRUPTION)  HOWEVER  CAUSED  AND  ON  ANY  THEORY OF LIABILITY,
+** WHETHER  IN  CONTRACT,   STRICT   LIABILITY,  OR  TORT  (INCLUDING
+** NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+** SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*/
+
+#ifndef APG_OWN_TYPES_H
+#define APG_OWN_TYPES_H	1
+
+typedef unsigned int	      UINT;
+typedef unsigned short	      USHORT;
+typedef short int	      SHORT;
+typedef int   		      boolean;
+typedef unsigned long int     UINT32;
+
+#define TRUE	1
+#define FALSE	0
+
+#define APG_MAX_PASSWORD_LENGTH 255
+
+#endif /* APG_OWN_TYPES_H */
@@ -0,0 +1,84 @@
+/*
+** This module uses code from the NIST implementation of  FIPS-181,
+** but the algorythm is CHANGED and I think that I CAN
+** copyright it. See copiright notes below.
+*/
+
+/*
+** Copyright (c) 1999, 2000, 2001, 2002, 2003
+** Adel I. Mirzazhanov. All rights reserved
+**
+** Redistribution and use in source and binary forms, with or without
+** modification, are permitted provided that the following conditions
+** are met:
+** 
+**     1.Redistributions of source code must retain the above copyright notice,
+**       this list of conditions and the following disclaimer. 
+**     2.Redistributions in binary form must reproduce the above copyright
+**       notice, this list of conditions and the following disclaimer in the
+**       documentation and/or other materials provided with the distribution. 
+**     3.The name of the author may not be used to endorse or promote products
+**       derived from this software without specific prior written permission. 
+** 		  
+** THIS SOFTWARE IS PROVIDED BY THE AUTHOR  ``AS IS'' AND ANY EXPRESS
+** OR IMPLIED WARRANTIES, INCLUDING,  BUT NOT LIMITED TO, THE IMPLIED
+** WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+** ARE DISCLAIMED.  IN  NO  EVENT  SHALL THE AUTHOR BE LIABLE FOR ANY
+** DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+** DAMAGES (INCLUDING, BUT NOT LIMITED TO,  PROCUREMENT OF SUBSTITUTE
+** GOODS OR SERVICES;  LOSS OF USE,  DATA,  OR  PROFITS;  OR BUSINESS
+** INTERRUPTION)  HOWEVER  CAUSED  AND  ON  ANY  THEORY OF LIABILITY,
+** WHETHER  IN  CONTRACT,   STRICT   LIABILITY,  OR  TORT  (INCLUDING
+** NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+** SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*/
+
+
+#ifndef APG_PRONPASS_H
+#define APG_PRONPASS_H	1
+
+#ifndef APG_OWN_TYPES_H
+#include "owntypes.h"
+#endif /* APG_OWN_TYPES_H */
+
+#ifndef APG_RND_H
+#include "rnd.h"
+#endif /* APG_RND_H */
+
+#define RULE_SIZE             (sizeof(rules)/sizeof(struct unit))
+#define ALLOWED(flag)         (digram[units_in_syllable[current_unit -1]][unit] & (flag))
+
+#define MAX_UNACCEPTABLE      20
+#define MAX_RETRIES           (4 * (int) pwlen + RULE_SIZE)
+
+#define NOT_BEGIN_SYLLABLE    010
+#define NO_FINAL_SPLIT        04
+#define VOWEL                 02
+#define ALTERNATE_VOWEL       01
+#define NO_SPECIAL_RULE       0
+
+#define BEGIN                 0200
+#define NOT_BEGIN             0100
+#define BREAK                 040
+#define PREFIX                020
+#define ILLEGAL_PAIR          010
+#define SUFFIX                04
+#define END                   02
+#define NOT_END               01
+#define ANY_COMBINATION       0
+
+extern int gen_pron_pass (char *word, char *hyphenated_word, USHORT minlen,
+               USHORT maxlen, unsigned int pass_mode);
+
+USHORT  random_unit (USHORT type);
+USHORT  get_random (USHORT minlen, USHORT maxlen);
+boolean have_initial_y (USHORT *units, USHORT unit_size);
+boolean illegal_placement (USHORT *units, USHORT pwlen);
+boolean improper_word (USHORT *units, USHORT word_size);
+boolean have_final_split (USHORT *units, USHORT unit_size);
+int gen_word (char *word, char *hyphenated_word, USHORT pwlen,
+              unsigned int pass_mode);
+char   	*gen_syllable(char *syllable, USHORT pwlen, USHORT *units_in_syllable,
+                      USHORT *syllable_length);
+
+#endif /* APG_PRONPASS_H */
@@ -0,0 +1,163 @@
+/*
+** Copyright (c) 1999, 2000, 2001, 2002, 2003
+** Adel I. Mirzazhanov. All rights reserved
+**
+** Redistribution and use in source and binary forms, with or without
+** modification, are permitted provided that the following conditions
+** are met:
+** 
+**     1.Redistributions of source code must retain the above copyright notice,
+**       this list of conditions and the following disclaimer. 
+**     2.Redistributions in binary form must reproduce the above copyright
+**       notice, this list of conditions and the following disclaimer in the
+**       documentation and/or other materials provided with the distribution. 
+**     3.The name of the author may not be used to endorse or promote products
+**       derived from this software without specific prior written permission. 
+** 		  
+** THIS SOFTWARE IS PROVIDED BY THE AUTHOR  ``AS IS'' AND ANY EXPRESS
+** OR IMPLIED WARRANTIES, INCLUDING,  BUT NOT LIMITED TO, THE IMPLIED
+** WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+** ARE DISCLAIMED.  IN  NO  EVENT  SHALL THE AUTHOR BE LIABLE FOR ANY
+** DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+** DAMAGES (INCLUDING, BUT NOT LIMITED TO,  PROCUREMENT OF SUBSTITUTE
+** GOODS OR SERVICES;  LOSS OF USE,  DATA,  OR  PROFITS;  OR BUSINESS
+** INTERRUPTION)  HOWEVER  CAUSED  AND  ON  ANY  THEORY OF LIABILITY,
+** WHETHER  IN  CONTRACT,   STRICT   LIABILITY,  OR  TORT  (INCLUDING
+** NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+** SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*/
+
+/*
+** randpass.c - Random password generation module of PWGEN program
+*/
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <time.h>
+#if !defined(WIN32) && !defined(_WIN32) && !defined(__WIN32) && !defined(__WIN32__)
+#include <pwd.h>
+#endif
+#include <unistd.h>
+#include "randpass.h"
+
+#include "owntypes.h"
+#include "smbl.h"
+
+/*
+** gen_rand_pass - generates random password of specified type
+** INPUT:
+**   char * - password string.
+**   int    - minimum password length.
+**   int    - maximum password length.
+**   unsigned int - password generation mode.
+** OUTPUT:
+**   int - password length or -1 on error.
+** NOTES:
+**   none.
+*/
+int
+gen_rand_pass (char *password_string, int minl, int maxl, unsigned int pass_mode)
+{
+  int i = 0;
+  int j = 0;
+  int length = 0;
+  char *str_pointer;
+  int random_weight[94];
+  int max_weight = 0;
+  int max_weight_element_number = 0;
+
+  if (minl > APG_MAX_PASSWORD_LENGTH || maxl > APG_MAX_PASSWORD_LENGTH ||
+      minl < 1 || maxl < 1 || minl > maxl)
+      return (-1);
+  for (i = 0; i <= 93; i++) random_weight[i] = 0; 
+  length = minl + randint(maxl-minl+1);
+  str_pointer = password_string;
+
+  for (i = 0; i < length; i++)
+    {
+/* Asign random weight in weight array if mode is present*/
+      for (j = 0; j <= 93 ; j++)
+         if ( ( (pass_mode & smbl[j].type) > 0) &&
+	     !( (S_RS & smbl[j].type) > 0))
+	    random_weight[j] = 1 + randint(20000);
+      j = 0;
+/* Find an element with maximum weight */
+      for (j = 0; j <= 93; j++)
+	if (random_weight[j] > max_weight)
+	  {
+	    max_weight = random_weight[j];
+	    max_weight_element_number = j;
+	  }
+/* Get password symbol */
+      *str_pointer = smbl[max_weight_element_number].ch;
+      str_pointer++;
+      max_weight = 0;
+      max_weight_element_number = 0;
+      for (j = 0; j <= 93; j++) random_weight[j] = 0;
+    }
+  *str_pointer = 0;
+  return (length);
+}
+
+/*
+** gen_rand_symbol - generates random password of specified type
+** INPUT:
+**   char * - symbol.
+**   unsigned int - symbol type.
+** OUTPUT:
+**   int - password length or -1 on error.
+** NOTES:
+**   none.
+*/
+int
+gen_rand_symbol (char *symbol, unsigned int mode)
+{
+  int j = 0;
+  char *str_pointer;
+  int random_weight[94];
+  int max_weight = 0;
+  int max_weight_element_number = 0;
+
+  for (j = 0; j <= 93; j++) random_weight[j] = 0; 
+  str_pointer = symbol;
+  j = 0;
+/* Asign random weight in weight array if mode is present*/
+  for (j = 0; j <= 93 ; j++)
+     if ( ( (mode & smbl[j].type) > 0) &&
+         !( (S_RS & smbl[j].type) > 0))
+	   random_weight[j] = 1 + randint(20000);
+  j = 0;
+/* Find an element with maximum weight */
+  for (j = 0; j <= 93; j++)
+     if (random_weight[j] > max_weight)
+       {
+        max_weight = random_weight[j];
+        max_weight_element_number = j;
+       }
+/* Get password symbol */
+  *str_pointer = smbl[max_weight_element_number].ch;
+  max_weight = 0;
+  max_weight_element_number = 0;
+  return (0);
+}
+
+/*
+** is_restricted_symbol - detcts if symbol is restricted rigt now
+** INPUT:
+**   char - symbol.
+** OUTPUT:
+**   int - 0 - not restricted
+**         1 - restricted
+** NOTES:
+**   none.
+*/
+int
+is_restricted_symbol (char symbol)
+{
+  int j = 0;
+  for (j = 0; j <= 93 ; j++)
+    if (symbol == smbl[j].ch)
+      if ((S_RS & smbl[j].type) > 0)
+        return(1);
+  return(0);
+}
@@ -0,0 +1,62 @@
+/*
+** Copyright (c) 1999, 2000, 2001, 2002, 2003
+** Adel I. Mirzazhanov. All rights reserved
+**
+** Redistribution and use in source and binary forms, with or without
+** modification, are permitted provided that the following conditions
+** are met:
+** 
+**     1.Redistributions of source code must retain the above copyright notice,
+**       this list of conditions and the following disclaimer. 
+**     2.Redistributions in binary form must reproduce the above copyright
+**       notice, this list of conditions and the following disclaimer in the
+**       documentation and/or other materials provided with the distribution. 
+**     3.The name of the author may not be used to endorse or promote products
+**       derived from this software without specific prior written permission. 
+** 		  
+** THIS SOFTWARE IS PROVIDED BY THE AUTHOR  ``AS IS'' AND ANY EXPRESS
+** OR IMPLIED WARRANTIES, INCLUDING,  BUT NOT LIMITED TO, THE IMPLIED
+** WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+** ARE DISCLAIMED.  IN  NO  EVENT  SHALL THE AUTHOR BE LIABLE FOR ANY
+** DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+** DAMAGES (INCLUDING, BUT NOT LIMITED TO,  PROCUREMENT OF SUBSTITUTE
+** GOODS OR SERVICES;  LOSS OF USE,  DATA,  OR  PROFITS;  OR BUSINESS
+** INTERRUPTION)  HOWEVER  CAUSED  AND  ON  ANY  THEORY OF LIABILITY,
+** WHETHER  IN  CONTRACT,   STRICT   LIABILITY,  OR  TORT  (INCLUDING
+** NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+** SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*/
+
+/*
+** randpass.h
+*/
+#ifndef APG_RANDPASS_H
+#define APG_RANDPASS_H	1
+
+#ifndef APG_RND_H
+#include "rnd.h"
+#endif
+
+#ifndef APG_OWN_TYPES_H
+#include "owntypes.h"
+#endif
+
+#define S_NB	0x01 /* Numeric */
+#define S_SS	0x02 /* Special */
+#define S_CL	0x04 /* Capital */
+#define S_SL	0x08 /* Small   */
+#define S_RS    0x10 /* Restricted Symbol*/
+
+struct sym
+ {
+  char   ch;
+  USHORT type;
+ };
+
+/* char gen_symbol(unsigned short int symbol_class); */
+extern int gen_rand_pass(char* password_string, int minl,
+                         int maxl, unsigned int pass_mode);
+extern int gen_rand_symbol (char *symbol, unsigned int mode);
+extern int is_restricted_symbol (char symbol);
+
+#endif /* RANDPASS_H */
@@ -0,0 +1,273 @@
+/*
+** Copyright (c) 1999, 2000, 2001, 2002, 2003
+** Adel I. Mirzazhanov. All rights reserved
+**
+** Redistribution and use in source and binary forms, with or without
+** modification, are permitted provided that the following conditions
+** are met:
+** 
+**     1.Redistributions of source code must retain the above copyright notice,
+**       this list of conditions and the following disclaimer. 
+**     2.Redistributions in binary form must reproduce the above copyright
+**       notice, this list of conditions and the following disclaimer in the
+**       documentation and/or other materials provided with the distribution. 
+**     3.The name of the author may not be used to endorse or promote products
+**       derived from this software without specific prior written permission. 
+** 		  
+** THIS SOFTWARE IS PROVIDED BY THE AUTHOR  ``AS IS'' AND ANY EXPRESS
+** OR IMPLIED WARRANTIES, INCLUDING,  BUT NOT LIMITED TO, THE IMPLIED
+** WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+** ARE DISCLAIMED.  IN  NO  EVENT  SHALL THE AUTHOR BE LIABLE FOR ANY
+** DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+** DAMAGES (INCLUDING, BUT NOT LIMITED TO,  PROCUREMENT OF SUBSTITUTE
+** GOODS OR SERVICES;  LOSS OF USE,  DATA,  OR  PROFITS;  OR BUSINESS
+** INTERRUPTION)  HOWEVER  CAUSED  AND  ON  ANY  THEORY OF LIABILITY,
+** WHETHER  IN  CONTRACT,   STRICT   LIABILITY,  OR  TORT  (INCLUDING
+** NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+** SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*/
+
+/*
+** restrict.c
+*/
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include "restrict.h"
+extern struct sym smbl[94];
+/*
+** check_pass() - routine that checks if password exist in dictionary
+** INPUT:
+**   char * - password to check.
+**   char * - dictionary filename.
+** OUTPUT:
+**   int
+**    -1 - error 
+**     1 - password exist in dictionary
+**     0 - password does not exist in dictionary
+** NOTES:
+**   none.
+*/
+int
+check_pass(char *pass, char *dict)
+{
+ FILE *dct;
+ char *string;
+ char *tmp;
+ if( (string = (char *) calloc(1,MAX_DICT_STRING_SIZE)) == NULL)
+   return(-1);
+ 
+#ifdef APG_DEBUG
+ fprintf (stdout, "DEBUG> check_pass: ck pass: %s\n", pass);
+ fflush (stdout);
+#endif /* APG_DEBUG */
+ /*
+ ** Open dict file an report of error
+ */
+ if ( (dct = fopen(dict,"r")) == NULL)
+   return(-1);
+
+ while ((fgets(string, MAX_DICT_STRING_SIZE, dct) != NULL))
+  {
+   tmp = strtok (string," \t\n\0");
+   if( tmp != NULL)
+     string = tmp;
+   else
+     continue;
+   if(strlen(string) != strlen(pass)) continue;
+   else if (strncmp(string, pass, strlen(pass)) == 0)
+    {
+     free ( (void *)string);
+     fclose (dct);
+#ifdef APG_DEBUG
+     fprintf (stdout, "DEBUG> check_pass: password found in dictionary: %s\n", pass);
+     fflush (stdout);
+#endif /* APG_DEBUG */
+     return (1);
+    }
+  }
+ free ( (void *)string);
+ fclose (dct);
+ return (0); 
+}
+
+/*
+** bloom_check_pass() - routine that checks if password exist in dictionary
+** using Bloom filter.
+** INPUT:
+**   char * - password to check.
+**   char * - bloom-filter filename.
+** OUTPUT:
+**   int
+**    -1 - error 
+**     1 - password exist in dictionary
+**     0 - password does not exist in dictionary
+** NOTES:
+**   none.
+*/
+int
+bloom_check_pass (char *word, char *filter)
+{
+ int ret = 0;
+ FILE *f_filter;
+ h_val filter_size = 0L;
+ f_mode flt_mode = 0x00;
+ if ( (f_filter = open_filter(filter,"r")) == NULL)
+    return(-1);
+ filter_size = get_filtersize(f_filter);
+ flt_mode =    get_filtermode(f_filter);
+ ret = check_word (word, f_filter, filter_size, flt_mode);
+ close_filter(f_filter);
+ return(ret);
+}
+
+/*
+** paranoid_bloom_check_pass() - routine that checks if password or any
+** substring of the password exist in dictionary using Bloom filter.
+** INPUT:
+**   char * - password to check.
+**   char * - bloom-filter filename.
+**   USHORT - minimum substring length
+** OUTPUT:
+**   int
+**    -1 - error 
+**     1 - password exist in dictionary
+**     0 - password does not exist in dictionary
+** NOTES:
+**   none.
+*/
+int
+paranoid_bloom_check_pass (char * password, char *filter, USHORT s_len)
+{
+ char * substring;
+ int len = strlen(password); /* string length                      */
+ int c_substr_start_pos = 0; /* current start position             */
+ int substr_len = 0;         /* substring length (LEN-I >= substr_len >= 2) */
+ int k = 0;                  /* counter                            */
+ int c = 0;                  /* counter                            */
+ int ret = 0;
+ if (s_len < 2) s_len = 2;
+ if (s_len > len) return (bloom_check_pass(password, filter));
+
+#ifdef APG_DEBUG
+ fprintf (stdout, "DEBUG> paranoid_bloom_check_pass: ck pass: %s\n", password);
+ fflush (stdout);
+#endif /* APG_DEBUG */
+
+ if ((substring = (char *)calloc(1, (size_t)len))==NULL)
+   return (-1);
+ 
+ for (c_substr_start_pos = 0; c_substr_start_pos <= len-s_len; c_substr_start_pos++)
+  for (substr_len = s_len; substr_len <= len-c_substr_start_pos; substr_len++)
+   {
+    c = 0;
+    for (k = c_substr_start_pos; k <= c_substr_start_pos + substr_len-1; k++)
+     {
+      substring[c]=password[k];
+      c++;
+     }
+#ifdef APG_DEBUG
+    fprintf (stdout, "DEBUG> paranoid_bloom_check_pass: ck substr: %s\n", substring);
+    fflush (stdout);
+#endif /* APG_DEBUG */
+    if((ret = bloom_check_pass(substring, filter)) == 1)
+    {
+#ifdef APG_DEBUG
+     fprintf (stdout, "DEBUG> paranoid_bloom_check_pass: substr found in filter: %s\n", substring);
+     fflush (stdout);
+#endif /* APG_DEBUG */
+     return(1);
+    }
+    else if (ret == -1) return(-1);
+    (void)memset(substring,0,(size_t)len);
+   }
+ return(0);
+}
+
+/*
+** filter_check_pass() - routine that checks password against filter string
+**
+** INPUT:
+**   char * - password to check.
+**   char * - bloom-filter filename.
+** OUTPUT:
+**   int
+**    -1 - error 
+**     1 - password do not pass the filter
+**     0 - password pass the filter
+** NOTES:
+**   none.
+*/
+
+int
+filter_check_pass(const char * word, unsigned int cond)
+{
+ int i = 0;
+ int sl_ret = 0;
+ int cl_ret = 0;
+ int nb_ret = 0;
+ int ss_ret = 0;
+
+#ifdef APG_DEBUG
+ fprintf (stdout, "DEBUG> filter_check_pass: ck pass: %s\n", word);
+ fflush (stdout);
+#endif /* APG_DEBUG */
+
+ if ((cond & S_SS) > 0)
+    for (i=0; i < 94; i++)
+       if ((smbl[i].type & S_SS) > 0)
+          if ((strchr(word,smbl[i].ch)) != NULL)
+	     ss_ret = 1;
+ i = 0;
+ if ((cond & S_SL) > 0)
+    for (i=0; i < 94; i++)
+       if ((smbl[i].type & S_SL) > 0)
+          if ((strchr(word,smbl[i].ch)) != NULL)
+	     sl_ret = 1;
+ i = 0;
+ if ((cond & S_CL) > 0)
+    for (i=0; i < 94; i++)
+       if ((smbl[i].type & S_CL) > 0)
+          if ((strchr(word,smbl[i].ch)) != NULL)
+	     cl_ret = 1;
+ i = 0;
+ if ((cond & S_NB) > 0)
+    for (i=0; i < 94; i++)
+       if ((smbl[i].type & S_NB) > 0)
+          if ((strchr(word,smbl[i].ch)) != NULL)
+	     nb_ret = 1;
+ if (((cond & S_SS) > 0) &&(ss_ret != 1)) return (1);
+ if (((cond & S_SL) > 0) &&(sl_ret != 1)) return (1);
+ if (((cond & S_CL) > 0) &&(cl_ret != 1)) return (1);
+ if (((cond & S_NB) > 0) &&(nb_ret != 1)) return (1);
+
+#ifdef APG_DEBUG
+ fprintf (stdout, "DEBUG> filter_check_pass: password %s pass the filter\n", word);
+ fflush (stdout);
+#endif /* APG_DEBUG */
+ return(0);
+}
+
+/*
+** set_exclude_list() - set up character list that should
+** be excluded from password generation process
+**
+** INPUT:
+**   char * - string of characters.
+** OUTPUT:
+**   int - return code
+**    0 - OK
+**   -1 - char_string is too long (max 93) 
+** NOTES:
+**   none.
+*/
+int set_exclude_list(const char * char_string)
+{
+ int i = 0;
+ if (strlen(char_string) > 93)
+  return(-1);
+ for(i=0; i < 94; i++)
+  if ((strchr(char_string, smbl[i].ch)) != NULL)
+    smbl[i].type = smbl[i].type | S_RS;
+ return(0);
+}
@@ -0,0 +1,45 @@
+/*
+** Copyright (c) 1999, 2000, 2001, 2002, 2003
+** Adel I. Mirzazhanov. All rights reserved
+**
+** Redistribution and use in source and binary forms, with or without
+** modification, are permitted provided that the following conditions
+** are met:
+** 
+**     1.Redistributions of source code must retain the above copyright notice,
+**       this list of conditions and the following disclaimer. 
+**     2.Redistributions in binary form must reproduce the above copyright
+**       notice, this list of conditions and the following disclaimer in the
+**       documentation and/or other materials provided with the distribution. 
+**     3.The name of the author may not be used to endorse or promote products
+**       derived from this software without specific prior written permission. 
+** 		  
+** THIS SOFTWARE IS PROVIDED BY THE AUTHOR  ``AS IS'' AND ANY EXPRESS
+** OR IMPLIED WARRANTIES, INCLUDING,  BUT NOT LIMITED TO, THE IMPLIED
+** WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+** ARE DISCLAIMED.  IN  NO  EVENT  SHALL THE AUTHOR BE LIABLE FOR ANY
+** DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+** DAMAGES (INCLUDING, BUT NOT LIMITED TO,  PROCUREMENT OF SUBSTITUTE
+** GOODS OR SERVICES;  LOSS OF USE,  DATA,  OR  PROFITS;  OR BUSINESS
+** INTERRUPTION)  HOWEVER  CAUSED  AND  ON  ANY  THEORY OF LIABILITY,
+** WHETHER  IN  CONTRACT,   STRICT   LIABILITY,  OR  TORT  (INCLUDING
+** NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+** SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*/
+
+/*
+** restrict.h
+*/
+#ifndef APG_RESTRICT_H
+#define APG_RESTRICT_H	1
+
+#include "bloom.h"
+#include "randpass.h"
+#define MAX_DICT_STRING_SIZE	255
+int check_pass(char * pass, char *dict);
+int bloom_check_pass (char *word, char *filter);
+int paranoid_bloom_check_pass (char * password, char *filter, USHORT s_len);
+int filter_check_pass(const char * word, unsigned int cond);
+int set_exclude_list(const char * char_string);
+
+#endif /* APG_RESTRICT_H */
@@ -0,0 +1,214 @@
+/*
+** Copyright (c) 1999, 2000, 2001, 2002, 2003
+** Adel I. Mirzazhanov. All rights reserved
+**
+** Redistribution and use in source and binary forms, with or without
+** modification, are permitted provided that the following conditions
+** are met:
+** 
+**     1.Redistributions of source code must retain the above copyright notice,
+**       this list of conditions and the following disclaimer. 
+**     2.Redistributions in binary form must reproduce the above copyright
+**       notice, this list of conditions and the following disclaimer in the
+**       documentation and/or other materials provided with the distribution. 
+**     3.The name of the author may not be used to endorse or promote products
+**       derived from this software without specific prior written permission. 
+** 		  
+** THIS SOFTWARE IS PROVIDED BY THE AUTHOR  ``AS IS'' AND ANY EXPRESS
+** OR IMPLIED WARRANTIES, INCLUDING,  BUT NOT LIMITED TO, THE IMPLIED
+** WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+** ARE DISCLAIMED.  IN  NO  EVENT  SHALL THE AUTHOR BE LIABLE FOR ANY
+** DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+** DAMAGES (INCLUDING, BUT NOT LIMITED TO,  PROCUREMENT OF SUBSTITUTE
+** GOODS OR SERVICES;  LOSS OF USE,  DATA,  OR  PROFITS;  OR BUSINESS
+** INTERRUPTION)  HOWEVER  CAUSED  AND  ON  ANY  THEORY OF LIABILITY,
+** WHETHER  IN  CONTRACT,   STRICT   LIABILITY,  OR  TORT  (INCLUDING
+** NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+** SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*/
+
+#include <stdio.h>
+#include <stdlib.h>
+#if !defined(WIN32) && !defined(_WIN32) && !defined(__WIN32) && !defined(__WIN32__)
+#include <strings.h>
+#endif
+#include <string.h>
+#include <unistd.h>
+#include <sys/types.h>
+#include <sys/time.h>
+#include "rnd.h"
+
+#ifndef APG_USE_SHA 
+#  include "./cast/cast.h"
+#else /* APG_USE_SHA */
+#  include "./sha/sha.h"
+#endif /* APG_USE_SHA */
+
+UINT32 __rnd_seed[2]; /* Random Seed 2*32=64 */
+
+/*
+** randint(int n) - Produces a Random number from 0 to n-1.
+** INPUT:
+**   int - limit
+** OUTPUT:
+**   UINT - pandom number.
+** NOTES:
+**   none.
+*/
+UINT
+randint(int n)
+{
+#ifndef APG_USE_SHA
+ return ( (UINT)( x917cast_rnd() % (UINT32)n ) );
+#else /* APG_USE_SHA */
+ return ( (UINT)( x917sha1_rnd() % (UINT32)n ) );
+#endif /* APG_USE_SHA */
+}
+
+#ifndef APG_USE_SHA
+/*
+** ANSI X9.17 pseudorandom generator that uses CAST algorithm instead of DES
+** m = 1
+** INPUT:
+**   none.
+** OUTPUT:
+**   UINT32 - random number.
+** NOTES:
+**   none.
+*/
+UINT32
+x917cast_rnd (void)
+{
+#if !defined(WIN32) && !defined(_WIN32) && !defined(__WIN32) && !defined(__WIN32__)
+ struct timeval local_time; 
+#else
+ clock_t local_time[2]; /* clock ticks for win32 */
+#endif
+ UINT32 I[2] = {0L,0L};
+ UINT32 I_plus_s[2] = {0L,0L};
+ UINT32 Xi[2] = {0L,0L};
+ UINT32 Xi_plus_I[2] = {0L,0L};
+ cast_key ky;
+ 
+/**********************************************************************
+* ENCRYPTION KEY HEX : 0x000102030405060708090A0B0C0D0E0F (128-bit)   *
+* YOU CAN CHANGE IT IF YOU WANT                                       *
+**********************************************************************/
+u8 ro_key[16] = { 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
+0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f};
+/**********************************************************************
+* ENCRYPTION KEY HEX : 0x000102030405060708090A0B0C0D0E0F (128-bit)   *
+* YOU CAN CHANGE IT IF YOU WANT                                       *
+**********************************************************************/
+#if !defined(WIN32) && !defined(_WIN32) && !defined(__WIN32) && !defined(__WIN32__)
+ (void) gettimeofday (&local_time, 0);
+#else
+ local_time[0] = clock();
+ local_time[1] = clock();
+#endif
+ cast_setkey(&ky, (u8*)&ro_key[0], 16);
+ cast_encrypt (&ky, (u8 *)&local_time, (u8*)&I[0]);            /* I=Ek(D), D-time  */
+ I_plus_s[0] = I[0] ^ __rnd_seed[0];                           /* I0 (+) s0        */
+ I_plus_s[1] = I[1] ^ __rnd_seed[1];                           /* I1 (+) s1        */
+ cast_encrypt (&ky, (u8 *)&I_plus_s[0], (u8*)&Xi[0]);          /* Xi=Ek( I (+) s ) */
+ Xi_plus_I[0] = Xi[0] ^ I[0];                                  /* Xi0 (+) I0       */
+ Xi_plus_I[1] = Xi[1] ^ I[1];                                  /* Xi1 (+) I1       */
+ cast_encrypt (&ky, (u8 *)&Xi_plus_I[0], (u8*)&__rnd_seed[0]); /* s=Ek( Xi (+) I ) */
+ return (Xi[0]);
+}
+#else /* APG_USE_SHA */
+/*
+** ANSI X9.17 pseudorandom generator that uses SHA1 algorithm instead of DES
+** m=1
+** INPUT:
+**   none.
+** OUTPUT:
+**   UINT32 - random number.
+** NOTES:
+**   none.
+*/
+UINT32
+x917sha1_rnd (void)
+{
+ struct timeval local_time;
+ UINT32 I[2] = {0L,0L};
+ UINT32 I_plus_s[2] = {0L,0L};
+ UINT32 Xi[2] = {0L,0L};
+ UINT32 Xi_plus_I[2] = {0L,0L};
+
+ BYTE hash [SHA_DIGESTSIZE];
+ apg_SHA_INFO shaInfo;
+
+ (void) gettimeofday (&local_time, 0);
+ apg_shaInit ( &shaInfo );
+ apg_shaUpdate ( &shaInfo, (BYTE *)&local_time, 8);
+ apg_shaFinal ( &shaInfo, hash );
+ (void)memcpy ( (void *)&I[0], (void *)&hash[0], sizeof(I));
+ I_plus_s[0] = I[0] ^ __rnd_seed[0];                           /* I0 (+) s0        */
+ I_plus_s[1] = I[1] ^ __rnd_seed[1];                           /* I1 (+) s1        */
+
+ apg_shaInit(&shaInfo);
+ apg_shaUpdate( &shaInfo, (BYTE *)&I_plus_s, 8);
+ apg_shaFinal( &shaInfo, hash );
+ (void)memcpy ( (void *)&Xi[0], (void *)&hash[0], sizeof(Xi));        /* Xi=Ek( I (+) s ) */
+
+ Xi_plus_I[0] = Xi[0] ^ I[0];                                  /* Xi0 (+) I0       */
+ Xi_plus_I[1] = Xi[1] ^ I[1];                                  /* Xi1 (+) I1       */
+
+ apg_shaInit(&shaInfo);
+ apg_shaUpdate( &shaInfo, (BYTE *)&Xi_plus_I, 8);
+ apg_shaFinal(&shaInfo, hash);
+ (void)memcpy ( (void *)&__rnd_seed[0], (void *)&hash[0],
+         sizeof(__rnd_seed));                                  /* s=Ek( Xi (+) I ) */
+ return (Xi[0]);
+}
+#endif /* APG_USE_SHA */
+/*
+** x917_setseed (UINT32 seed) - Initializes seed
+** INPUT:
+**   UINT32 - seed value
+**   int - quiet mode flag
+** OUTPUT:
+**   none.
+** NOTES:
+**   none.
+*/
+void
+x917_setseed (UINT32 seed, int quiet)
+{
+ FILE * dr;
+ UINT32 drs[2];
+ UINT32 pid = 0;
+
+ pid = (UINT32)getpid();
+
+ if ( (dr = fopen(APG_DEVRANDOM, "r")) != NULL)
+  {
+   (void)fread( (void *)&drs[0], 8, 1, dr);
+   __rnd_seed[0] = seed ^ drs[0];
+   __rnd_seed[1] = seed ^ drs[1];
+   (void) fclose(dr);
+  }
+ else if ( (dr = fopen(APG_DEVURANDOM, "r")) != NULL)
+  {
+   (void)fread( (void *)&drs[0], 8, 1, dr);
+   __rnd_seed[0] = seed ^ drs[0];
+   __rnd_seed[1] = seed ^ drs[1];
+   (void) fclose(dr);
+  }
+ else
+  {
+#ifndef CLISERV
+#if !defined(WIN32) && !defined(_WIN32) && !defined(__WIN32) && !defined(__WIN32__)
+   if (quiet != TRUE)
+    {
+     fprintf(stderr,"CAN NOT USE RANDOM DEVICE TO GENERATE RANDOM SEED\n");
+     fprintf(stderr,"USING LOCAL TIME AND PID FOR SEED GENERATION !!!\n");
+     fflush(stderr);
+    }
+#endif /* WIN32 */
+#endif /* CLISERV */
+   __rnd_seed[0] = seed ^ pid;
+   __rnd_seed[1] = seed ^ pid;
+  }
+}
@@ -0,0 +1,55 @@
+/*
+** Copyright (c) 1999, 2000, 2001, 2002, 2003
+** Adel I. Mirzazhanov. All rights reserved
+**
+** Redistribution and use in source and binary forms, with or without
+** modification, are permitted provided that the following conditions
+** are met:
+** 
+**     1.Redistributions of source code must retain the above copyright notice,
+**       this list of conditions and the following disclaimer. 
+**     2.Redistributions in binary form must reproduce the above copyright
+**       notice, this list of conditions and the following disclaimer in the
+**       documentation and/or other materials provided with the distribution. 
+**     3.The name of the author may not be used to endorse or promote products
+**       derived from this software without specific prior written permission. 
+** 		  
+** THIS SOFTWARE IS PROVIDED BY THE AUTHOR  ``AS IS'' AND ANY EXPRESS
+** OR IMPLIED WARRANTIES, INCLUDING,  BUT NOT LIMITED TO, THE IMPLIED
+** WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+** ARE DISCLAIMED.  IN  NO  EVENT  SHALL THE AUTHOR BE LIABLE FOR ANY
+** DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+** DAMAGES (INCLUDING, BUT NOT LIMITED TO,  PROCUREMENT OF SUBSTITUTE
+** GOODS OR SERVICES;  LOSS OF USE,  DATA,  OR  PROFITS;  OR BUSINESS
+** INTERRUPTION)  HOWEVER  CAUSED  AND  ON  ANY  THEORY OF LIABILITY,
+** WHETHER  IN  CONTRACT,   STRICT   LIABILITY,  OR  TORT  (INCLUDING
+** NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+** SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*/
+
+#ifndef APG_RND_H
+#define APG_RND_H	1
+
+#ifndef APG_OWN_TYPES_H
+#include "owntypes.h"
+#endif /* OWN_TYPES_H */
+
+extern UINT32 __rnd_seed[2];
+
+#define RND_MX 0x7FFFFFFF
+#ifdef __OpenBSD__
+#define APG_DEVRANDOM "/dev/arandom"
+#else
+#define APG_DEVRANDOM "/dev/random"
+#endif /* __OpenBSD__ */
+#define APG_DEVURANDOM "/dev/urandom"
+
+extern void x917_setseed (UINT32 seed, int quiet);
+extern UINT randint (int n);
+#ifndef APG_USE_SHA
+UINT32 x917cast_rnd (void);
+#else /* APG_USE_SHA */
+UINT32 x917sha1_rnd (void);
+#endif /* APG_USE_SHA*/
+
+#endif /* APG_RND_H */
@@ -0,0 +1,297 @@
+/***************************************************************************/
+/* sha.c								   */
+/*									   */
+/* Public domain SHA-1 implementation.					   */
+/*									   */
+/* Taken from the SHA implementation by Peter C. Gutmann of 9/2/1992	   */
+/* and modified by Carl Ellison to be SHA-1.				   */
+/***************************************************************************/
+
+/*
+** Note regarding apg_* namespace: this avoids potential conflicts
+** with libraries.
+*/
+
+#include <string.h>
+#include "sha.h"
+
+/* The SHA f()-functions */
+
+#define f1(x,y,z)   ( ( x & y ) | ( ~x & z ) )              /* Rounds  0-19 */
+#define f2(x,y,z)   ( x ^ y ^ z )                           /* Rounds 20-39 */
+#define f3(x,y,z)   ( ( x & y ) | ( x & z ) | ( y & z ) )   /* Rounds 40-59 */
+#define f4(x,y,z)   ( x ^ y ^ z )                           /* Rounds 60-79 */
+
+/* The SHA Mysterious Constants */
+
+#define K1  0x5A827999L     /* Rounds  0-19 */
+#define K2  0x6ED9EBA1L     /* Rounds 20-39 */
+#define K3  0x8F1BBCDCL     /* Rounds 40-59 */
+#define K4  0xCA62C1D6L     /* Rounds 60-79 */
+
+/* SHA initial values */
+
+#define h0init  0x67452301L
+#define h1init  0xEFCDAB89L
+#define h2init  0x98BADCFEL
+#define h3init  0x10325476L
+#define h4init  0xC3D2E1F0L
+
+/* 32-bit rotate - kludged with shifts */
+
+typedef unsigned long UL ;	/* to save space */
+
+#define S(n,X)  ( ( ((UL)X) << n ) | ( ((UL)X) >> ( 32 - n ) ) )
+
+/* The initial expanding function */
+
+#define expand(count)   W[ count ] = S(1,(W[ count - 3 ] ^ W[ count - 8 ] ^ W[ count - 14 ] ^ W[ count - 16 ]))	/* to make this SHA-1 */
+
+/* The four SHA sub-rounds */
+
+#define subRound1(count)    \
+{ \
+    temp = S( 5, A ) + f1( B, C, D ) + E + W[ count ] + K1; \
+    E = D; \
+    D = C; \
+    C = S( 30, B ); \
+    B = A; \
+    A = temp; \
+}
+
+#define subRound2(count)    \
+{ \
+    temp = S( 5, A ) + f2( B, C, D ) + E + W[ count ] + K2; \
+    E = D; \
+    D = C; \
+    C = S( 30, B ); \
+    B = A; \
+    A = temp; \
+}
+
+#define subRound3(count)    \
+{ \
+    temp = S( 5, A ) + f3( B, C, D ) + E + W[ count ] + K3; \
+    E = D; \
+    D = C; \
+    C = S( 30, B ); \
+    B = A; \
+    A = temp; \
+}
+
+#define subRound4(count)    \
+{ \
+    temp = S( 5, A ) + f4( B, C, D ) + E + W[ count ] + K4; \
+    E = D; \
+    D = C; \
+    C = S( 30, B ); \
+    B = A; \
+    A = temp; \
+}
+
+/* The two buffers of 5 32-bit words */
+
+LONG h0, h1, h2, h3, h4;
+LONG A, B, C, D, E;
+
+/***************************************************************************/
+/* apg_shaInit								   */
+/*									   */
+/* Initialize the SHA values 						   */
+/***************************************************************************/
+
+void apg_shaInit( apg_SHA_INFO *shaInfo )
+{
+  /* Set the h-vars to their initial values */
+  shaInfo->digest[ 0 ] = h0init;
+  shaInfo->digest[ 1 ] = h1init;
+  shaInfo->digest[ 2 ] = h2init;
+  shaInfo->digest[ 3 ] = h3init;
+  shaInfo->digest[ 4 ] = h4init;
+
+  /* Initialise bit count */
+  shaInfo->countLo = shaInfo->countHi = 0L;
+  shaInfo->slop = 0 ;		/* no data saved yet in data[] */
+} /* apg_shaInit */
+
+/***************************************************************************/
+/* shaTransform								   */
+/*									   */
+/* Perform the SHA transformation over one input block.			   */
+/***************************************************************************/
+
+static void shaTransform( apg_SHA_INFO *shaInfo )
+{
+  LONG W[ 80 ], temp;
+  int i;
+
+  /* Step A.  Copy the data buffer into the local work buffer */
+  for( i = 0; i < 16; i++ )
+    W[ i ] = shaInfo->data[ i ];
+
+  /* Step B.  Expand the 16 words into 64 temporary data words */
+  expand( 16 ); expand( 17 ); expand( 18 ); expand( 19 ); expand( 20 );
+  expand( 21 ); expand( 22 ); expand( 23 ); expand( 24 ); expand( 25 );
+  expand( 26 ); expand( 27 ); expand( 28 ); expand( 29 ); expand( 30 );
+  expand( 31 ); expand( 32 ); expand( 33 ); expand( 34 ); expand( 35 );
+  expand( 36 ); expand( 37 ); expand( 38 ); expand( 39 ); expand( 40 );
+  expand( 41 ); expand( 42 ); expand( 43 ); expand( 44 ); expand( 45 );
+  expand( 46 ); expand( 47 ); expand( 48 ); expand( 49 ); expand( 50 );
+  expand( 51 ); expand( 52 ); expand( 53 ); expand( 54 ); expand( 55 );
+  expand( 56 ); expand( 57 ); expand( 58 ); expand( 59 ); expand( 60 );
+  expand( 61 ); expand( 62 ); expand( 63 ); expand( 64 ); expand( 65 );
+  expand( 66 ); expand( 67 ); expand( 68 ); expand( 69 ); expand( 70 );
+  expand( 71 ); expand( 72 ); expand( 73 ); expand( 74 ); expand( 75 );
+  expand( 76 ); expand( 77 ); expand( 78 ); expand( 79 );
+
+  /* Step C.  Set up first buffer */
+  A = shaInfo->digest[ 0 ];
+  B = shaInfo->digest[ 1 ];
+  C = shaInfo->digest[ 2 ];
+  D = shaInfo->digest[ 3 ];
+  E = shaInfo->digest[ 4 ];
+
+  /* Step D.  Serious mangling, divided into four sub-rounds */
+  subRound1( 0 ); subRound1( 1 ); subRound1( 2 ); subRound1( 3 );
+  subRound1( 4 ); subRound1( 5 ); subRound1( 6 ); subRound1( 7 );
+  subRound1( 8 ); subRound1( 9 ); subRound1( 10 ); subRound1( 11 );
+  subRound1( 12 ); subRound1( 13 ); subRound1( 14 ); subRound1( 15 );
+  subRound1( 16 ); subRound1( 17 ); subRound1( 18 ); subRound1( 19 );
+  subRound2( 20 ); subRound2( 21 ); subRound2( 22 ); subRound2( 23 );
+  subRound2( 24 ); subRound2( 25 ); subRound2( 26 ); subRound2( 27 );
+  subRound2( 28 ); subRound2( 29 ); subRound2( 30 ); subRound2( 31 );
+  subRound2( 32 ); subRound2( 33 ); subRound2( 34 ); subRound2( 35 );
+  subRound2( 36 ); subRound2( 37 ); subRound2( 38 ); subRound2( 39 );
+  subRound3( 40 ); subRound3( 41 ); subRound3( 42 ); subRound3( 43 );
+  subRound3( 44 ); subRound3( 45 ); subRound3( 46 ); subRound3( 47 );
+  subRound3( 48 ); subRound3( 49 ); subRound3( 50 ); subRound3( 51 );
+  subRound3( 52 ); subRound3( 53 ); subRound3( 54 ); subRound3( 55 );
+  subRound3( 56 ); subRound3( 57 ); subRound3( 58 ); subRound3( 59 );
+  subRound4( 60 ); subRound4( 61 ); subRound4( 62 ); subRound4( 63 );
+  subRound4( 64 ); subRound4( 65 ); subRound4( 66 ); subRound4( 67 );
+  subRound4( 68 ); subRound4( 69 ); subRound4( 70 ); subRound4( 71 );
+  subRound4( 72 ); subRound4( 73 ); subRound4( 74 ); subRound4( 75 );
+  subRound4( 76 ); subRound4( 77 ); subRound4( 78 ); subRound4( 79 );
+
+  /* Step E.  Build message digest */
+  shaInfo->digest[ 0 ] += A;
+  shaInfo->digest[ 1 ] += B;
+  shaInfo->digest[ 2 ] += C;
+  shaInfo->digest[ 3 ] += D;
+  shaInfo->digest[ 4 ] += E;
+} /* shaTransform */
+
+#ifdef APG_LITTLE_ENDIAN
+
+/***************************************************************************/
+/* byteReverse								   */
+/*									   */
+/* When run on a little-endian CPU we need to perform byte reversal on an  */
+/* array of longwords.  It is possible to make the code endianness-	   */
+/* independant by fiddling around with data at the byte level, but this	   */
+/* makes for very slow code, so we rely on the user to sort out endianness */
+/* at compile time.							   */
+/***************************************************************************/
+
+static void byteReverse( LONG *buffer, int byteCount )
+{
+  LONG value;
+  int count;
+
+  byteCount /= sizeof( LONG );
+  for( count = 0; count < byteCount; count++ )
+    {
+      value = ( buffer[ count ] << 16 ) | ( buffer[ count ] >> 16 );
+      buffer[ count ] = ( ( value & 0xFF00FF00L ) >> 8 ) | ( ( value & 0x00FF00FFL ) << 8 );
+    } /* for */
+} /* byteReverse */
+#endif /* APG_LITTLE_ENDIAN */
+
+/***************************************************************************/
+/* apg_shaUpdate								   */
+/*									   */
+/* Update SHA for a block of data.					   */
+/* Use any data already in the SHA_INFO structure and leave any partial	   */
+/* data block there.							   */
+/***************************************************************************/
+
+void apg_shaUpdate( apg_SHA_INFO *shaInfo, BYTE *buffer, int count )
+{
+  BYTE *db ;
+   
+  db = (BYTE *) &(shaInfo->data[0]) ;
+
+  /* Update bitcount */
+  if( ( shaInfo->countLo + ( ( LONG ) count << 3 ) ) < shaInfo->countLo )
+    shaInfo->countHi++; /* Carry from low to high bitCount */
+  shaInfo->countLo += ( ( LONG ) count << 3 );
+  shaInfo->countHi += ( ( LONG ) count >> 29 );
+
+  /* Process data in SHA_BLOCKSIZE chunks */
+  while ( count-- > 0 )
+    {
+      db[ shaInfo->slop++ ] = *(buffer++) ;
+      if (shaInfo->slop == SHA_BLOCKSIZE)
+	{ /* transform this one block */
+#ifdef APG_LITTLE_ENDIAN
+	  byteReverse( shaInfo->data, SHA_BLOCKSIZE );
+#endif /* APG_LITTLE_ENDIAN */
+	  shaTransform( shaInfo );
+	  shaInfo->slop = 0 ;	/* no slop left */
+	} /* if */
+    } /* while */
+} /* apg_shaUpdate */
+
+/***************************************************************************/
+/* apg_shaFinal								   */
+/*									   */
+/* Handle the last piece of data -- if any is left over in the data	   */
+/* buffer -- and append padding and a bit count for the last block	   */
+/* to process.  Having transformed that block, pull the digest out	   */
+/* as a byte array.							   */
+/***************************************************************************/
+
+void apg_shaFinal( apg_SHA_INFO *shaInfo, BYTE hash[SHA_DIGESTSIZE] )
+{
+  int count;
+  LONG lowBitcount = shaInfo->countLo, highBitcount = shaInfo->countHi;
+
+  /* Compute number of bytes mod 64 */
+  count = ( int ) ( ( shaInfo->countLo >> 3 ) & 0x3F );
+
+  /* Set the first char of padding to 0x80.  This is safe since there is
+     always at least one byte free */
+  ( ( BYTE * ) shaInfo->data )[ count++ ] = 0x80;
+
+  /* Pad out to 56 mod 64 */
+  if( count > 56 )
+    {
+      /* Two lots of padding:  Pad the first block to 64 bytes */
+      memset( ( BYTE * ) &shaInfo->data + count, 0, 64 - count );
+#ifdef APG_LITTLE_ENDIAN
+      byteReverse( shaInfo->data, SHA_BLOCKSIZE );
+#endif /* APG_LITTLE_ENDIAN */
+      shaTransform( shaInfo );
+
+      /* Now fill the next block with 56 bytes */
+      memset( &shaInfo->data, 0, 56 );
+    }
+  else
+    /* Pad block to 56 bytes */
+    memset( ( BYTE * ) &shaInfo->data + count, 0, 56 - count );
+#ifdef APG_LITTLE_ENDIAN
+  byteReverse( shaInfo->data, SHA_BLOCKSIZE );
+#endif /* APG_LITTLE_ENDIAN */
+
+  /* Append length in bits and transform */
+  shaInfo->data[ 14 ] = highBitcount;
+  shaInfo->data[ 15 ] = lowBitcount;
+
+  shaTransform( shaInfo );
+#ifdef APG_LITTLE_ENDIAN
+  byteReverse( shaInfo->data, SHA_DIGESTSIZE );
+#endif /* APG_LITTLE_ENDIAN */
+
+  for (count=0; count<SHA_DIGESTSIZE; count++)
+    hash[count] = (BYTE) ((shaInfo->digest[count>>2]) >> (8*(3-(count & 0x3)))) & 0xff ;
+} /* apg_shaFinal */
@@ -0,0 +1,39 @@
+/***************************************************************************/
+/* sha.h								   */
+/*									   */
+/* SHA-1 code header file.						   */
+/* Taken from the public domain implementation by Peter C. Gutmann	   */
+/* on 2 Sep 1992, modified by Carl Ellison to be SHA-1.			   */
+/***************************************************************************/
+
+#ifndef _SHA_H_
+#define _SHA_H_
+
+/* Define APG_LITTLE_ENDIAN if the machine is little-endian */
+
+#define APG_LITTLE_ENDIAN
+
+/* Useful defines/typedefs */
+
+typedef unsigned char   BYTE ;
+typedef unsigned long   LONG ;
+
+/* The SHA block size and message digest sizes, in bytes */
+
+#define SHA_BLOCKSIZE   64
+#define SHA_DIGESTSIZE  20
+
+/* The structure for storing SHA info */
+
+typedef struct {
+  LONG digest[ 5 ] ;            /* Message digest */
+  LONG countLo, countHi ;       /* 64-bit bit count */
+  LONG data[ 16 ] ;             /* SHA data buffer */
+  LONG slop ;			/* # of bytes saved in data[] */
+} apg_SHA_INFO ;
+
+void apg_shaInit( apg_SHA_INFO *shaInfo ) ;
+void apg_shaUpdate( apg_SHA_INFO *shaInfo, BYTE *buffer, int count ) ;
+void apg_shaFinal( apg_SHA_INFO *shaInfo, BYTE hash[SHA_DIGESTSIZE] ) ;
+
+#endif /* _SHA_H_ */
@@ -0,0 +1,51 @@
+/*
+** Copyright (c) 1999, 2000, 2001, 2002, 2003
+** Adel I. Mirzazhanov. All rights reserved
+**
+** Redistribution and use in source and binary forms, with or without
+** modification, are permitted provided that the following conditions
+** are met:
+** 
+**     1.Redistributions of source code must retain the above copyright notice,
+**       this list of conditions and the following disclaimer. 
+**     2.Redistributions in binary form must reproduce the above copyright
+**       notice, this list of conditions and the following disclaimer in the
+**       documentation and/or other materials provided with the distribution. 
+**     3.The name of the author may not be used to endorse or promote products
+**       derived from this software without specific prior written permission. 
+** 		  
+** THIS SOFTWARE IS PROVIDED BY THE AUTHOR  ``AS IS'' AND ANY EXPRESS
+** OR IMPLIED WARRANTIES, INCLUDING,  BUT NOT LIMITED TO, THE IMPLIED
+** WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+** ARE DISCLAIMED.  IN  NO  EVENT  SHALL THE AUTHOR BE LIABLE FOR ANY
+** DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+** DAMAGES (INCLUDING, BUT NOT LIMITED TO,  PROCUREMENT OF SUBSTITUTE
+** GOODS OR SERVICES;  LOSS OF USE,  DATA,  OR  PROFITS;  OR BUSINESS
+** INTERRUPTION)  HOWEVER  CAUSED  AND  ON  ANY  THEORY OF LIABILITY,
+** WHETHER  IN  CONTRACT,   STRICT   LIABILITY,  OR  TORT  (INCLUDING
+** NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+** SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*/
+#ifndef APG_SMBL_H
+#define APG_SMBL_H    1
+struct sym smbl[94] = 
+{
+ {'a', S_SL}, {'b', S_SL}, {'c', S_SL}, {'d', S_SL}, {'e', S_SL}, {'f', S_SL},
+ {'g', S_SL}, {'h', S_SL}, {'i', S_SL}, {'j', S_SL}, {'k', S_SL}, {'l', S_SL},
+ {'m', S_SL}, {'n', S_SL}, {'o', S_SL}, {'p', S_SL}, {'q', S_SL}, {'r', S_SL},
+ {'s', S_SL}, {'t', S_SL}, {'u', S_SL}, {'v', S_SL}, {'w', S_SL}, {'x', S_SL},
+ {'y', S_SL}, {'z', S_SL}, {'A', S_CL}, {'B', S_CL}, {'C', S_CL}, {'D', S_CL},
+ {'E', S_CL}, {'F', S_CL}, {'G', S_CL}, {'H', S_CL}, {'I', S_CL}, {'J', S_CL},
+ {'K', S_CL}, {'L', S_CL}, {'M', S_CL}, {'N', S_CL}, {'O', S_CL}, {'P', S_CL},
+ {'Q', S_CL}, {'R', S_CL}, {'S', S_CL}, {'T', S_CL}, {'U', S_CL}, {'V', S_CL},
+ {'W', S_CL}, {'X', S_CL}, {'Y', S_CL}, {'Z', S_CL}, {'1', S_NB}, {'2', S_NB},
+ {'3', S_NB}, {'4', S_NB}, {'5', S_NB}, {'6', S_NB}, {'7', S_NB}, {'8', S_NB},
+ {'9', S_NB}, {'0', S_NB}, {33 , S_SS}, {34 , S_SS}, {35 , S_SS}, {36 , S_SS},
+ {37 , S_SS}, {38 , S_SS}, {39 , S_SS}, {40 , S_SS}, {41 , S_SS}, {42 , S_SS},
+ {43 , S_SS}, {44 , S_SS}, {45 , S_SS}, {46 , S_SS}, {47 , S_SS}, {58 , S_SS},
+ {59 , S_SS}, {60 , S_SS}, {61 , S_SS}, {62 , S_SS}, {63 , S_SS}, {64 , S_SS},
+ {91 , S_SS}, {92 , S_SS}, {93 , S_SS}, {94 , S_SS}, {95 , S_SS}, {96 , S_SS},
+ {123, S_SS}, {124, S_SS}, {125, S_SS}, {126, S_SS}
+};
+
+#endif /* APG_SMBL_H */