working on sha512_internal

config/sha512.c

@@ -0,0 +1 @@
+../src/lib/sha512.c

configure

@@ -306,6 +306,7 @@ do
     --silence=options)	silentopt=yes ;;
     --md5=internal)	ft_md5=internal ;;
     --sha=internal)	ft_sha=internal ;;
+    --sha=internal512)	ft_sha=internal512 ;;
     --use-cpuflags)	cc_arch_opt=yes ;;
     --no-cpuflags)	cc_arch_opt=no ;;
     --use-optimize)	cc_optimize_opt=yes ;;
@@ -636,7 +637,7 @@ fi
 
 oflag="-O2"
 if [ "$optitype" = size ]; then
-  oflag="-Os"
+  oflag="-Os -fcf-protection=none"
 fi
 
 if [ -z "$cf_cflags" -a -z "$cc_optimize_opt" ]; then
@@ -853,20 +854,35 @@ if [ ! "$ft_sha" = no ]; then
   TESTC=config/pw.c
   echo $ac_n "checking for SHA in crypt() ... "$ac_c
   sha_internal=
+  sha_object=
   crypt_func='-DCRYPT_FUNC=crypt'
   CRYPT_FUNCTION='#define CRYPT_FUNC crypt'
+  if [ "$ft_sha" = internal512 ]; then
+    sha_internal=config/sha512.c
+    sha_object=config/sha512.o
+    crypt_func='-DCRYPT_FUNC=__crypt_sha512'
+    CRYPT_FUNCTION='#define CRYPT_FUNC __crypt_sha512'
+    $CC -c $sha_internal -o $sha_object
+  fi
   if [ "$ft_sha" = internal ]; then
-    sha_internal=config/sha_internal.c
+    sha_internal=config/sha1.c
+    sha_object=config/sha1.o
     crypt_func='-DCRYPT_FUNC=sha_crypt'
     CRYPT_FUNCTION='#define CRYPT_FUNC sha_crypt'
   fi
-  $CC -o $TESTP $TESTC $sha_internal $crypt_func 1> /dev/null 2> /dev/null
+  #
+  $CC -o $TESTP $TESTC $sha_object $crypt_func 1> /dev/null 2> /dev/null
+  #
   if [ ! -x $TESTP ]; then
+    crypt_func='-DCRYPT_FUNC=crypt'
+    CRYPT_FUNCTION='#define CRYPT_FUNC crypt'
     libcrypt=-lcrypt
     has_sha=yes
     $CC -o $TESTP $TESTC $crypt_func $libcrypt 1> /dev/null 2> /dev/null
   fi
   if [ ! -x $TESTP ]; then
+    crypt_func='-DCRYPT_FUNC=crypt'
+    CRYPT_FUNCTION='#define CRYPT_FUNC crypt'
     libcrypt=/usr/lib/libcrypt.so
     has_sha=yes
     $CC -o $TESTP $TESTC $crypt_func $libcrypt 1> /dev/null 2> /dev/null
@@ -879,6 +895,7 @@ if [ ! "$ft_sha" = no ]; then
     pwhash=`$TESTP`
     case "$pwhash" in
       MD5 ) has_md5=yes ;;
+      SHA ) has_sha=yes ;;
       SHAMD5 )
         has_md5=yes
         has_sha=yes
@@ -887,9 +904,8 @@ if [ ! "$ft_sha" = no ]; then
   fi
   echo $ac_t "$has_sha"
   [ "$has_sha" = yes -a "$sha_internal" ] && has_sha=internal
-  rm -f $TESTP
+  rm -f $TESTP $sha_object
 fi
-
 #
 #  check for MD5 capabilities in libc/glibc/libcrypt
 #
@@ -898,13 +914,13 @@ if [ "$has_md5" = yes ]; then
 elif [ "$ft_md5" = no ]; then
   has_md5=notest
 elif [ ! "$ft_md5" = no ]; then
-  TESTC=config/pw.c
   echo $ac_n "checking for MD5 in crypt() ... "$ac_c
+  TESTC=config/pw.c
   md5_internal=
   crypt_func='-DCRYPT_FUNC=crypt'
   CRYPT_FUNCTION='#define CRYPT_FUNC crypt'
   if [ "$ft_md5" = internal ]; then
-    md5_internal=config/md5_internal.c
+    md5_internal=config/md5.c
     crypt_func='-DCRYPT_FUNC=md5_crypt'
     CRYPT_FUNCTION='#define CRYPT_FUNC md5_crypt'
   fi
@@ -1107,7 +1123,11 @@ SHA_C=
 SHA_O=
 if [ "$ft_sha" = internal ]; then
   SHA_C=lib/sha1.c
-  SHA_O=lib/sha.o
+  SHA_O=lib/sha1.o
+fi
+if [ "$ft_sha" = internal512 ]; then
+  SHA_C=lib/sha512.c
+  SHA_O=lib/sha512.o
 fi
 
 out=echo
@@ -1306,7 +1326,7 @@ if [ "$has_sha" = no ]; then
 else
   test "$ft_sha" && $out "$ft_sha" && ans=$ft_sha
   test -z "$ft_sha" && read ans
-  test -z "$ans" -o "$ans" = y -o "$ans" = Y -o "$ans" = yes -o "$ans" = YES -o "$ans" = Yes -o "$ans" = internal && def_sha='#define SHACRYPT'
+  test -z "$ans" -o "$ans" = y -o "$ans" = Y -o "$ans" = yes -o "$ans" = YES -o "$ans" = Yes -o "$ans" = internal -o "$ans" = internal512 && def_sha='#define SHACRYPT'
 fi
 
 def_perl='#undef PERL'
@@ -1539,6 +1559,7 @@ save_myconfig() {
   test "$silentopt" = yes && echo "--silence=options \\" >> ./myconfig
   test "$ft_md5" = internal && echo "--md5=internal \\" >> ./myconfig
   test "$ft_sha" = internal && echo "--sha=internal \\" >> ./myconfig
+  test "$ft_sha" = internal512 && echo "--sha=internal512 \\" >> ./myconfig
   test "$optitype" = speed && echo "--optimize=speed \\" >> ./myconfig
   test "$optitype" = size && echo "--optimize=size \\" >> ./myconfig
   test "$cc_ofp_opt" = yes && echo "--use-ofp \\" >> ./myconfig

src/commands.h

@@ -0,0 +1,272 @@
+/*
+
+    EnergyMech, IRC bot software
+    Copyright (c) 1997-2025 proton
+
+    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 2 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, write to the Free Software
+    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+
+*/
+
+/*
+
+	These are defined in config.h
+
+	DCC	0x000100		requires DCC
+	CC	0x000200		requires commandchar
+	PASS	0x000400		requires password / authentication
+	CARGS	0x000800		requires args
+	NOPUB	0x001000		ignore in channel (for password commands)
+	NOCMD	0x002000		not allowed to be executed thru CMD
+	GAXS	0x004000		check global access
+	CAXS	0x008000		check channel access
+	REDIR	0x010000		may be redirected
+	LBUF	0x020000		can be linebuffered to server
+	CBANG	0x040000		command may be prefixed with a bang (!)
+	ACCHAN  0x080000		needs an active channel
+	SUPRES  0x100000		command is not suitable to run on many bots at once, try to suppress it
+
+	CLEVEL	0x000ff
+
+*/
+
+#define CCPW	CC|PASS
+
+struct
+{
+	int	pass;
+	const char *name;
+	const char *func;
+	uint32_t flags;
+	char	*cmdarg;
+
+} pre_mcmd[] =
+{
+	/*
+	 *  public access commands
+	 */
+	{ 0, "AUTH",		"do_auth",		 0		| NOPUB	| CBANG			}, // double up on AUTH/VERIFY to better
+	{ 0, "VERIFY",		"do_auth",		 0		| NOPUB	| CBANG			}, // catch login attempts
+#ifdef TOYBOX
+	{ 0, "8BALL",		"do_8ball",		 0		| CBANG	| SUPRES		},
+	{ 0, "RAND",		"do_rand",		 0		| CBANG	| SUPRES		},
+#endif /* TOYBOX */
+	{ 0, "CV",		"do_convert",		 0		| CBANG | SUPRES		},
+	{ 0, "CALC",		"do_calc",		 0		| CBANG | SUPRES		},
+
+	/*
+	 *  Level 10
+	 */
+	{ 0, "ACCESS",		"do_access",		10	| CCPW					},
+	{ 0, "BYE",		"do_bye",		10	| CC					},
+	{ 0, "CHAT",		"do_chat",		10	| CCPW	| NOCMD				},
+#ifdef RAWDNS
+	{ 0, "DNS",		"do_dns",		10	| CCPW	| GAXS | CARGS | SUPRES		},
+#endif /* RAWDNS */
+	{ 0, "DOWN",		"do_opdeopme",		10	| CC	| CAXS				},
+	{ 0, "ECHO",		"do_echo",		10	| CCPW	| CARGS				},
+	{ 0, "HELP",		"do_help",		10	| CCPW	| REDIR | LBUF | SUPRES		},
+	{ 0, "PASSWD",		"do_passwd",		10	| PASS	| NOPUB | CARGS			},
+#ifdef DCC_FILE
+	{ 0, "SEND",		"do_send",		10	| CC	| NOCMD	| CBANG	| CARGS		},
+#endif /* DCC_FILE */
+	{ 0, "USAGE",		"do_usage",		10	| CCPW	| REDIR	| CARGS			},
+
+	/*
+	 *  Level 20
+	 */
+	{ 0, "ONTIME",		"do_upontime",		20	| CCPW					, "Ontime: %s" },
+	{ 0, "UPTIME",		"do_upontime",		20	| CCPW					, "Uptime: %s" },
+	{ 0, "VER",		"do_version",		20	| CCPW					},
+	{ 0, "WHOM",		"do_whom",		20	| CCPW	| REDIR | LBUF			},
+#ifdef SEEN
+	{ 0, "SEEN",		"do_seen",		20	| CCPW	| CBANG				},
+#endif /* SEEN */
+#ifdef URLCAPTURE
+	{ 0, "URLHIST",		"do_urlhist",		20	| CCPW	| REDIR | LBUF			},
+#endif /* ifdef URLCAPTURE */
+
+	/*
+	 *  Level 40
+	 */
+	{ 0, "BAN",		"do_kickban",		40	| CCPW	| CAXS | CARGS | ACCHAN		, "\\x00ban\\0bann" },
+	{ 0, "BANLIST",		"do_banlist",		40	| CCPW	| CAXS | DCC | REDIR | LBUF | ACCHAN },
+	{ 0, "CCHAN",		"do_cchan",		40	| CCPW					},	/* global_access ? */
+	{ 0, "CSERV",		"do_cserv",		40	| CCPW					},
+	{ 0, "CHANNELS",	"do_channels",		40	| CCPW	| DCC				},
+	{ 0, "DEOP",		"do_opvoice",		40	| CCPW	| CAXS | CARGS			, "o-" },
+	{ 0, "ESAY",		"do_esay",		40	| CCPW	| CAXS | CARGS			},
+	{ 0, "IDLE",		"do_idle",		40	| CCPW	| CARGS				},
+	{ 0, "INVITE",		"do_invite",		40	| CCPW	| CAXS | ACCHAN			},
+	{ 0, "KB",		"do_kickban",		40	| CCPW	| CAXS | CARGS | ACCHAN		, "\\x04kickban\\0kickbann" },
+	{ 0, "KICK",		"do_kickban",		40	| CCPW	| CAXS | CARGS | ACCHAN		, "\\x07kick\\0kick" },
+	{ 0, "LUSERS",		"do_irclusers",		40	| CCPW	| DCC | REDIR | LBUF		},
+	{ 0, "ME",		"do_sayme",		40	| CCPW	| CARGS				},
+	{ 0, "MODE",		"do_mode",		40	| CCPW	| CARGS				},
+	{ 0, "NAMES",		"do_names",		40	| CCPW					},
+	{ 0, "OP",		"do_opvoice",		40	| CCPW	| CAXS				, "o+" },
+	{ 0, "SAY",		"do_sayme",		40	| CCPW	| CARGS				},
+	{ 0, "SCREW",		"do_kickban",		40	| CCPW	| CAXS | CARGS | ACCHAN		, "\\x02screwban\\0screwbann" },
+	{ 0, "SET",		"do_set",		40	| CCPW					},
+	{ 0, "SITEBAN",		"do_kickban",		40	| CCPW	| CAXS | CARGS | ACCHAN		, "\\x01siteban\\0sitebann" },
+	{ 0, "SITEKB",		"do_kickban",		40	| CCPW	| CAXS | CARGS | ACCHAN		, "\\x05sitekickban\\0sitekickbann" },
+	{ 0, "TIME",		"do_time",		40	| CCPW					},
+	{ 0, "TOPIC",		"do_topic",		40	| CCPW	| CAXS | CARGS | ACCHAN	| SUPRES },
+	{ 0, "UNBAN",		"do_unban",		40	| CCPW	| CAXS				},
+	{ 0, "UNVOICE",		"do_opvoice",		40	| CCPW	| CAXS | CARGS			, "v-" },
+	{ 0, "UP",		"do_opdeopme",		40	| CCPW	| CAXS				},
+	{ 0, "USER",		"do_user",		40	| CCPW	| CARGS				},
+	{ 0, "USERHOST",	"do_ircwhois",		40	| CCPW	| CARGS				},
+	{ 0, "VOICE",		"do_opvoice",		40	| CCPW	| CAXS				, "v+" },
+	{ 0, "WALL",		"do_wall",		40	| CCPW	| CAXS | CARGS | ACCHAN		},
+	{ 0, "WHO",		"do_who",		40	| CCPW	| CAXS | DCC			},
+	{ 0, "WHOIS",		"do_ircwhois",		40	| CCPW	| CARGS | DCC | REDIR | LBUF	},
+#ifdef NOTE
+	{ 0, "NOTE",		"do_note",		40	| CCPW	| CARGS				},
+	{ 0, "READ",		"do_read",		40	| CCPW					},
+#endif /* NOTE */
+#ifdef STATS
+	{ 0, "INFO",		"do_info",		40	| CCPW	| REDIR | CAXS | DCC		},
+#endif /* STATS */
+
+	/*
+	 *  Level 50
+	 */
+	{ 0, "QSHIT",		"do_shit",		50	| CCPW	| CARGS				},
+	{ 0, "RSHIT",		"do_rshit",		50	| CCPW	| CARGS				},
+	{ 0, "SHIT",		"do_shit",		50	| CCPW	| CARGS				},
+	{ 0, "SHITLIST",	"do_shitlist",		50	| CCPW	| DCC | REDIR | LBUF		},
+#ifdef GREET
+	{ 0, "GREET",		"do_greet",		50	| CCPW	| CARGS				},
+#endif /* GREET */
+#ifdef TOYBOX
+	{ 0, "INSULT",		"do_random_msg",	50	| CCPW					, RANDINSULTFILE },
+	{ 0, "PICKUP",		"do_random_msg",	50	| CCPW					, RANDPICKUPFILE },
+	{ 0, "RSAY",		"do_random_msg",	50	| CCPW					, RANDSAYFILE },
+	{ 0, "RT",		"do_randtopic",		50	| CCPW	| CAXS | ACCHAN			},
+	{ 0, "ASCII",		"do_ascii",		50	| CCPW	| CAXS | CARGS | SUPRES		},
+#endif /* TOYBOX */
+#ifdef TRIVIA
+	{ 0, "TRIVIA",		"do_trivia",		50	| CCPW	| CAXS | CARGS | CBANG		},
+#endif /* TRIVIA */
+
+	/*
+	 *  Level 60
+	 */
+	{ 0, "SHOWIDLE",	"do_showidle",		60	| CCPW	| CAXS | DCC | ACCHAN		},
+	{ 0, "USERLIST",	"do_userlist",		60	| CCPW	| DCC				},
+#ifdef CTCP
+	{ 0, "CTCP",		"do_ping_ctcp",		60	| CCPW	| CARGS				},
+	{ 0, "PING",		"do_ping_ctcp",		60	| CCPW	| CARGS				},
+#endif /* CTCP */
+
+	/*
+	 *  Level 70 == JOINLEVEL
+	 */
+	{ 0, "CYCLE",		"do_cycle",		70	| CCPW	| CAXS | ACCHAN			},
+	{ 0, "FORGET",		"do_forget",		70	| CCPW	| CAXS				},
+	{ 0, "JOIN",		"do_join",		70	| CCPW	| CARGS				},
+	{ 0, "KS",		"do_kicksay",		70	| CCPW	| REDIR | LBUF			},
+	{ 0, "PART",		"do_part",		70	| CCPW	| CAXS | ACCHAN			},
+	{ 0, "RKS",		"do_rkicksay",		70	| CCPW	| CARGS				},
+	{ 0, "SETPASS",		"do_setpass",		70	| CCPW	| NOPUB	| CARGS			},
+#ifdef NOTIFY
+	{ 0, "NOTIFY",		"do_notify",		70	| CCPW	| DCC | GAXS | REDIR | LBUF	},
+#endif /* NOTIFY */
+
+	/*
+	 *  Level 80 == ASSTLEVEL
+	 */
+	{ 0, "AWAY",		"do_away",		80	| CCPW	| GAXS				},
+	{ 0, "BOOT",		"do_boot",		80	| CCPW	| GAXS | CARGS			},
+#if defined(BOTNET) && defined(REDIRECT)
+	{ 0, "CMD",		"do_cmd",		80	| CCPW	| CARGS				},
+#endif /* BOTNET && REDIRECT */
+	{ 0, "CQ",		"do_clearqueue",	80	| CCPW	| GAXS				},
+	{ 0, "LAST",		"do_last",		80	| CCPW	| DCC				},
+	{ 0, "LOAD",		"do_load",		80	| CCPW	| GAXS				},
+	{ 0, "MSG",		"do_msg",		80	| CCPW	| CARGS				},
+	{ 0, "NEXTSERVER",	"do_server",		80	| CCPW	| GAXS				},
+	{ 0, "SAVE",		"do_save",		80	| CCPW	| GAXS				},
+	{ 0, "SERVER",		"do_server",		80	| CCPW	| GAXS | REDIR | LBUF		},
+	{ 0, "SERVERGROUP",	"do_servergroup",	80	| CCPW	| GAXS | REDIR | LBUF		},
+	{ 0, "STATS",		"do_ircstats",		80	| CCPW	| DCC | CARGS			},
+#ifdef ALIAS
+	{ 0, "ALIAS",		"do_alias",		80	| CCPW	| GAXS				},
+	{ 0, "UNALIAS",		"do_unalias",		80	| CCPW	| GAXS | CARGS			},
+#endif /* ALIAS */
+#ifdef TOYBOX
+	{ 0, "BIGSAY",		"do_bigsay",		80	| CCPW	| CAXS | CARGS | SUPRES		},
+#endif /* TOYBOX */
+
+	/*
+	 *  Level 90
+	 */
+	{ 0, "CLEARSHIT",	"do_clearshit",		90	| CCPW	| GAXS				},
+	{ 0, "DO",		"do_do",		90	| CCPW	| GAXS | CARGS			},
+	{ 0, "NICK",		"do_nick",		90	| CCPW	| GAXS | CARGS			},
+	{ 0, "RSPY",		"do_rspy",		90	| CCPW	| CARGS				},
+	{ 0, "SPY",		"do_spy",		90	| CCPW					},
+#ifdef BOTNET
+	{ 0, "LINK",		"do_link",		90	| CCPW	| GAXS				},
+#endif /* BOTNET */
+#ifdef DYNCMD
+	{ 0, "CHACCESS",	"do_chaccess",		90	| CCPW	| GAXS | CARGS			},
+#endif /* DYNCMD */
+#ifdef UPTIME
+	{ 0, "UPSEND",		"do_upsend",		90	| CCPW	| GAXS				},
+#endif /* UPTIME */
+
+	/*
+	 *  Level 100
+	 */
+#ifdef HOSTINFO
+	{ 0, "SYSINFO",		"do_sysinfo",		100	| CCPW	| GAXS				},
+	{ 0, "MEMINFO",		"do_meminfo",		100	| CCPW	| GAXS				},
+	{ 0, "CPUINFO",		"do_cpuinfo",		100	| CCPW	| GAXS				},
+	{ 0, "FILEMON",		"do_filemon",		100	| CCPW	| GAXS | CARGS			},
+#endif /* HOSTINFO */
+#ifdef RAWDNS
+	{ 0, "DNSSERVER",	"do_dnsserver",		100	| CCPW  | GAXS				},
+	{ 0, "DNSROOT",		"do_dnsroot",		100	| CCPW	| GAXS | CARGS			},
+#endif /* RAWDNS */
+	{ 0, "CORE",		"do_core",		100	| CCPW	| REDIR | DCC			},
+	{ 0, "DIE",		"do_die",		100	| CCPW	| GAXS				},
+	{ 0, "RESET",		"do_reset",		100	| CCPW	| GAXS | NOCMD			},
+	{ 0, "SHUTDOWN",	"do_shutdown",		100	| CCPW	| GAXS | NOPUB | NOCMD		},
+#ifdef DEBUG
+	{ 0, "DEBUG",		"do_debug",		100	| CCPW	| GAXS				},
+	{ 0, "CRASH",		"do_crash",		100	| CCPW	| GAXS				},
+#endif /* DEBUG */
+#ifdef PERL
+#ifdef PLEASE_HACK_MY_SHELL
+	{ 0, "PERL",		"do_perl",		100	| CCPW	| GAXS | CARGS			},
+#endif /* PLEASE_HACK_MY_SHELL */
+	{ 0, "PERLSCRIPT",	"do_perlscript",	100	| CCPW	| GAXS | CARGS			},
+#endif /* PERL */
+#ifdef PYTHON
+#ifdef PLEASE_HACK_MY_SHELL
+	{ 0, "PYTHON",		"do_python",		100	| CCPW	| GAXS | CARGS			},
+#endif /* PLEASE_HACK_MY_SHELL */
+	{ 0, "PYTHONSCRIPT",	"do_pythonscript",	100	| CCPW	| GAXS | CARGS			},
+#endif /* PYTHON */
+#ifdef TCL
+#ifdef PLEASE_HACK_MY_SHELL
+	{ 0, "TCL",		"do_tcl",		100	| CCPW	| GAXS | CARGS			},
+#endif /* PLEASE_HACK_MY_SHELL */
+	{ 0, "TCLSCRIPT",	"do_tcl",		100	| CCPW	| GAXS | CARGS			},
+#endif /* TCL */
+	/*---*/
+	{ 0, NULL,		NULL,			0						},
+};

src/global.h

@@ -42,8 +42,8 @@
 #define DEFAULTCMDCHAR			'-'
 #define MECHUSERLOGIN			"v3.energymech.net"
 
-BEG const char VERSION[]		MDEF("3.2p" GITHASH);
-BEG const char SRCDATE[]		MDEF("May 13th, 2024");
+BEG const char VERSION[]		MDEF("3.5.dev" GITHASH);
+BEG const char SRCDATE[]		MDEF("October 22nd, 2025");
 #ifdef __CYGWIN__
 BEG const char BOTCLASS[]		MDEF("WinMech");
 #else /* ! CYGWIN */

src/lib/sha1.c

@@ -294,4 +294,4 @@ int main(int argc, char **argv)
 	return(0);
 }
 
-#endif TEST
+#endif /* TEST */

src/lib/sha512.c

@@ -0,0 +1,371 @@
+/*
+ * public domain sha512 crypt implementation
+ *
+ * original sha crypt design: http://people.redhat.com/drepper/SHA-crypt.txt
+ * in this implementation at least 32bit int is assumed,
+ * key length is limited, the $6$ prefix is mandatory, '\n' and ':' is rejected
+ * in the salt and rounds= setting must contain a valid iteration count,
+ * on error "*" is returned.
+ */
+#include <ctype.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+#include <stdint.h>
+
+/* public domain sha512 implementation based on fips180-3 */
+/* >=2^64 bits messages are not supported (about 2000 peta bytes) */
+
+struct sha512 {
+	uint64_t len;     /* processed message length */
+	uint64_t h[8];    /* hash state */
+	uint8_t buf[128]; /* message block buffer */
+};
+
+static uint64_t ror(uint64_t n, int k) { return (n >> k) | (n << (64-k)); }
+#define Ch(x,y,z)  (z ^ (x & (y ^ z)))
+#define Maj(x,y,z) ((x & y) | (z & (x | y)))
+#define S0(x)      (ror(x,28) ^ ror(x,34) ^ ror(x,39))
+#define S1(x)      (ror(x,14) ^ ror(x,18) ^ ror(x,41))
+#define R0(x)      (ror(x,1) ^ ror(x,8) ^ (x>>7))
+#define R1(x)      (ror(x,19) ^ ror(x,61) ^ (x>>6))
+
+static const uint64_t K[80] = {
+0x428a2f98d728ae22ULL, 0x7137449123ef65cdULL, 0xb5c0fbcfec4d3b2fULL, 0xe9b5dba58189dbbcULL,
+0x3956c25bf348b538ULL, 0x59f111f1b605d019ULL, 0x923f82a4af194f9bULL, 0xab1c5ed5da6d8118ULL,
+0xd807aa98a3030242ULL, 0x12835b0145706fbeULL, 0x243185be4ee4b28cULL, 0x550c7dc3d5ffb4e2ULL,
+0x72be5d74f27b896fULL, 0x80deb1fe3b1696b1ULL, 0x9bdc06a725c71235ULL, 0xc19bf174cf692694ULL,
+0xe49b69c19ef14ad2ULL, 0xefbe4786384f25e3ULL, 0x0fc19dc68b8cd5b5ULL, 0x240ca1cc77ac9c65ULL,
+0x2de92c6f592b0275ULL, 0x4a7484aa6ea6e483ULL, 0x5cb0a9dcbd41fbd4ULL, 0x76f988da831153b5ULL,
+0x983e5152ee66dfabULL, 0xa831c66d2db43210ULL, 0xb00327c898fb213fULL, 0xbf597fc7beef0ee4ULL,
+0xc6e00bf33da88fc2ULL, 0xd5a79147930aa725ULL, 0x06ca6351e003826fULL, 0x142929670a0e6e70ULL,
+0x27b70a8546d22ffcULL, 0x2e1b21385c26c926ULL, 0x4d2c6dfc5ac42aedULL, 0x53380d139d95b3dfULL,
+0x650a73548baf63deULL, 0x766a0abb3c77b2a8ULL, 0x81c2c92e47edaee6ULL, 0x92722c851482353bULL,
+0xa2bfe8a14cf10364ULL, 0xa81a664bbc423001ULL, 0xc24b8b70d0f89791ULL, 0xc76c51a30654be30ULL,
+0xd192e819d6ef5218ULL, 0xd69906245565a910ULL, 0xf40e35855771202aULL, 0x106aa07032bbd1b8ULL,
+0x19a4c116b8d2d0c8ULL, 0x1e376c085141ab53ULL, 0x2748774cdf8eeb99ULL, 0x34b0bcb5e19b48a8ULL,
+0x391c0cb3c5c95a63ULL, 0x4ed8aa4ae3418acbULL, 0x5b9cca4f7763e373ULL, 0x682e6ff3d6b2b8a3ULL,
+0x748f82ee5defb2fcULL, 0x78a5636f43172f60ULL, 0x84c87814a1f0ab72ULL, 0x8cc702081a6439ecULL,
+0x90befffa23631e28ULL, 0xa4506cebde82bde9ULL, 0xbef9a3f7b2c67915ULL, 0xc67178f2e372532bULL,
+0xca273eceea26619cULL, 0xd186b8c721c0c207ULL, 0xeada7dd6cde0eb1eULL, 0xf57d4f7fee6ed178ULL,
+0x06f067aa72176fbaULL, 0x0a637dc5a2c898a6ULL, 0x113f9804bef90daeULL, 0x1b710b35131c471bULL,
+0x28db77f523047d84ULL, 0x32caab7b40c72493ULL, 0x3c9ebe0a15c9bebcULL, 0x431d67c49c100d4cULL,
+0x4cc5d4becb3e42b6ULL, 0x597f299cfc657e2aULL, 0x5fcb6fab3ad6faecULL, 0x6c44198c4a475817ULL
+};
+
+static void processblock(struct sha512 *s, const uint8_t *buf)
+{
+	uint64_t W[80], t1, t2, a, b, c, d, e, f, g, h;
+	int i;
+
+	for (i = 0; i < 16; i++) {
+		W[i] = (uint64_t)buf[8*i]<<56;
+		W[i] |= (uint64_t)buf[8*i+1]<<48;
+		W[i] |= (uint64_t)buf[8*i+2]<<40;
+		W[i] |= (uint64_t)buf[8*i+3]<<32;
+		W[i] |= (uint64_t)buf[8*i+4]<<24;
+		W[i] |= (uint64_t)buf[8*i+5]<<16;
+		W[i] |= (uint64_t)buf[8*i+6]<<8;
+		W[i] |= buf[8*i+7];
+	}
+	for (; i < 80; i++)
+		W[i] = R1(W[i-2]) + W[i-7] + R0(W[i-15]) + W[i-16];
+	a = s->h[0];
+	b = s->h[1];
+	c = s->h[2];
+	d = s->h[3];
+	e = s->h[4];
+	f = s->h[5];
+	g = s->h[6];
+	h = s->h[7];
+	for (i = 0; i < 80; i++) {
+		t1 = h + S1(e) + Ch(e,f,g) + K[i] + W[i];
+		t2 = S0(a) + Maj(a,b,c);
+		h = g;
+		g = f;
+		f = e;
+		e = d + t1;
+		d = c;
+		c = b;
+		b = a;
+		a = t1 + t2;
+	}
+	s->h[0] += a;
+	s->h[1] += b;
+	s->h[2] += c;
+	s->h[3] += d;
+	s->h[4] += e;
+	s->h[5] += f;
+	s->h[6] += g;
+	s->h[7] += h;
+}
+
+static void pad(struct sha512 *s)
+{
+	unsigned r = s->len % 128;
+
+	s->buf[r++] = 0x80;
+	if (r > 112) {
+		memset(s->buf + r, 0, 128 - r);
+		r = 0;
+		processblock(s, s->buf);
+	}
+	memset(s->buf + r, 0, 120 - r);
+	s->len *= 8;
+	s->buf[120] = s->len >> 56;
+	s->buf[121] = s->len >> 48;
+	s->buf[122] = s->len >> 40;
+	s->buf[123] = s->len >> 32;
+	s->buf[124] = s->len >> 24;
+	s->buf[125] = s->len >> 16;
+	s->buf[126] = s->len >> 8;
+	s->buf[127] = s->len;
+	processblock(s, s->buf);
+}
+
+static void sha512_init(struct sha512 *s)
+{
+	s->len = 0;
+	s->h[0] = 0x6a09e667f3bcc908ULL;
+	s->h[1] = 0xbb67ae8584caa73bULL;
+	s->h[2] = 0x3c6ef372fe94f82bULL;
+	s->h[3] = 0xa54ff53a5f1d36f1ULL;
+	s->h[4] = 0x510e527fade682d1ULL;
+	s->h[5] = 0x9b05688c2b3e6c1fULL;
+	s->h[6] = 0x1f83d9abfb41bd6bULL;
+	s->h[7] = 0x5be0cd19137e2179ULL;
+}
+
+static void sha512_sum(struct sha512 *s, uint8_t *md)
+{
+	int i;
+
+	pad(s);
+	for (i = 0; i < 8; i++) {
+		md[8*i] = s->h[i] >> 56;
+		md[8*i+1] = s->h[i] >> 48;
+		md[8*i+2] = s->h[i] >> 40;
+		md[8*i+3] = s->h[i] >> 32;
+		md[8*i+4] = s->h[i] >> 24;
+		md[8*i+5] = s->h[i] >> 16;
+		md[8*i+6] = s->h[i] >> 8;
+		md[8*i+7] = s->h[i];
+	}
+}
+
+static void sha512_update(struct sha512 *s, const void *m, unsigned long len)
+{
+	const uint8_t *p = m;
+	unsigned r = s->len % 128;
+
+	s->len += len;
+	if (r) {
+		if (len < 128 - r) {
+			memcpy(s->buf + r, p, len);
+			return;
+		}
+		memcpy(s->buf + r, p, 128 - r);
+		len -= 128 - r;
+		p += 128 - r;
+		processblock(s, s->buf);
+	}
+	for (; len >= 128; len -= 128, p += 128)
+		processblock(s, p);
+	memcpy(s->buf, p, len);
+}
+
+static const unsigned char b64[] =
+"./0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
+
+static char *to64(char *s, unsigned int u, int n)
+{
+	while (--n >= 0) {
+		*s++ = b64[u % 64];
+		u /= 64;
+	}
+	return s;
+}
+
+/* key limit is not part of the original design, added for DoS protection.
+ * rounds limit has been lowered (versus the reference/spec), also for DoS
+ * protection. runtime is O(klen^2 + klen*rounds) */
+#define KEY_MAX 256
+#define SALT_MAX 16
+#define ROUNDS_DEFAULT 5000
+#define ROUNDS_MIN 1000
+#define ROUNDS_MAX 9999999
+
+/* hash n bytes of the repeated md message digest */
+static void hashmd(struct sha512 *s, unsigned int n, const void *md)
+{
+	unsigned int i;
+
+	for (i = n; i > 64; i -= 64)
+		sha512_update(s, md, 64);
+	sha512_update(s, md, i);
+}
+
+static char *sha512crypt(const char *key, const char *setting, char *output)
+{
+	struct sha512 ctx;
+	unsigned char md[64], kmd[64], smd[64];
+	unsigned int i, r, klen, slen;
+	char rounds[20] = "";
+	const char *salt;
+	char *p;
+
+	/* reject large keys */
+	for (i = 0; i <= KEY_MAX && key[i]; i++);
+	if (i > KEY_MAX)
+		return 0;
+	klen = i;
+
+	/* setting: $6$rounds=n$salt$ (rounds=n$ and closing $ are optional) */
+	if (strncmp(setting, "$6$", 3) != 0)
+		return 0;
+	salt = setting + 3;
+
+	r = ROUNDS_DEFAULT;
+	if (strncmp(salt, "rounds=", sizeof "rounds=" - 1) == 0) {
+		unsigned long u;
+		char *end;
+
+		/*
+		 * this is a deviation from the reference:
+		 * bad rounds setting is rejected if it is
+		 * - empty
+		 * - unterminated (missing '$')
+		 * - begins with anything but a decimal digit
+		 * the reference implementation treats these bad
+		 * rounds as part of the salt or parse them with
+		 * strtoul semantics which may cause problems
+		 * including non-portable hashes that depend on
+		 * the host's value of ULONG_MAX.
+		 */
+		salt += sizeof "rounds=" - 1;
+		if (!isdigit(*salt))
+			return 0;
+		u = strtoul(salt, &end, 10);
+		if (*end != '$')
+			return 0;
+		salt = end+1;
+		if (u < ROUNDS_MIN)
+			r = ROUNDS_MIN;
+		else if (u > ROUNDS_MAX)
+			return 0;
+		else
+			r = u;
+		/* needed when rounds is zero prefixed or out of bounds */
+		sprintf(rounds, "rounds=%u$", r);
+	}
+
+	for (i = 0; i < SALT_MAX && salt[i] && salt[i] != '$'; i++)
+		/* reject characters that interfere with /etc/shadow parsing */
+		if (salt[i] == '\n' || salt[i] == ':')
+			return 0;
+	slen = i;
+
+	/* B = sha(key salt key) */
+	sha512_init(&ctx);
+	sha512_update(&ctx, key, klen);
+	sha512_update(&ctx, salt, slen);
+	sha512_update(&ctx, key, klen);
+	sha512_sum(&ctx, md);
+
+	/* A = sha(key salt repeat-B alternate-B-key) */
+	sha512_init(&ctx);
+	sha512_update(&ctx, key, klen);
+	sha512_update(&ctx, salt, slen);
+	hashmd(&ctx, klen, md);
+	for (i = klen; i > 0; i >>= 1)
+		if (i & 1)
+			sha512_update(&ctx, md, sizeof md);
+		else
+			sha512_update(&ctx, key, klen);
+	sha512_sum(&ctx, md);
+
+	/* DP = sha(repeat-key), this step takes O(klen^2) time */
+	sha512_init(&ctx);
+	for (i = 0; i < klen; i++)
+		sha512_update(&ctx, key, klen);
+	sha512_sum(&ctx, kmd);
+
+	/* DS = sha(repeat-salt) */
+	sha512_init(&ctx);
+	for (i = 0; i < 16 + md[0]; i++)
+		sha512_update(&ctx, salt, slen);
+	sha512_sum(&ctx, smd);
+
+	/* iterate A = f(A,DP,DS), this step takes O(rounds*klen) time */
+	for (i = 0; i < r; i++) {
+		sha512_init(&ctx);
+		if (i % 2)
+			hashmd(&ctx, klen, kmd);
+		else
+			sha512_update(&ctx, md, sizeof md);
+		if (i % 3)
+			sha512_update(&ctx, smd, slen);
+		if (i % 7)
+			hashmd(&ctx, klen, kmd);
+		if (i % 2)
+			sha512_update(&ctx, md, sizeof md);
+		else
+			hashmd(&ctx, klen, kmd);
+		sha512_sum(&ctx, md);
+	}
+
+	/* output is $6$rounds=n$salt$hash */
+	p = output;
+	p += sprintf(p, "$6$%s%.*s$", rounds, slen, salt);
+#if 1
+	static const unsigned char perm[][3] = {
+		0,21,42,22,43,1,44,2,23,3,24,45,25,46,4,
+		47,5,26,6,27,48,28,49,7,50,8,29,9,30,51,
+		31,52,10,53,11,32,12,33,54,34,55,13,56,14,35,
+		15,36,57,37,58,16,59,17,38,18,39,60,40,61,19,
+		62,20,41 };
+	for (i=0; i<21; i++) p = to64(p,
+		(md[perm[i][0]]<<16)|(md[perm[i][1]]<<8)|md[perm[i][2]], 4);
+#else
+	p = to64(p, (md[0]<<16)|(md[21]<<8)|md[42], 4);
+	p = to64(p, (md[22]<<16)|(md[43]<<8)|md[1], 4);
+	p = to64(p, (md[44]<<16)|(md[2]<<8)|md[23], 4);
+	p = to64(p, (md[3]<<16)|(md[24]<<8)|md[45], 4);
+	p = to64(p, (md[25]<<16)|(md[46]<<8)|md[4], 4);
+	p = to64(p, (md[47]<<16)|(md[5]<<8)|md[26], 4);
+	p = to64(p, (md[6]<<16)|(md[27]<<8)|md[48], 4);
+	p = to64(p, (md[28]<<16)|(md[49]<<8)|md[7], 4);
+	p = to64(p, (md[50]<<16)|(md[8]<<8)|md[29], 4);
+	p = to64(p, (md[9]<<16)|(md[30]<<8)|md[51], 4);
+	p = to64(p, (md[31]<<16)|(md[52]<<8)|md[10], 4);
+	p = to64(p, (md[53]<<16)|(md[11]<<8)|md[32], 4);
+	p = to64(p, (md[12]<<16)|(md[33]<<8)|md[54], 4);
+	p = to64(p, (md[34]<<16)|(md[55]<<8)|md[13], 4);
+	p = to64(p, (md[56]<<16)|(md[14]<<8)|md[35], 4);
+	p = to64(p, (md[15]<<16)|(md[36]<<8)|md[57], 4);
+	p = to64(p, (md[37]<<16)|(md[58]<<8)|md[16], 4);
+	p = to64(p, (md[59]<<16)|(md[17]<<8)|md[38], 4);
+	p = to64(p, (md[18]<<16)|(md[39]<<8)|md[60], 4);
+	p = to64(p, (md[40]<<16)|(md[61]<<8)|md[19], 4);
+	p = to64(p, (md[62]<<16)|(md[20]<<8)|md[41], 4);
+#endif
+	p = to64(p, md[63], 2);
+	*p = 0;
+	return output;
+}
+
+char *__crypt_sha512(const char *key, const char *setting, char *output)
+{
+	static const char testkey[] = "Xy01@#\x01\x02\x80\x7f\xff\r\n\x81\t !";
+	static const char testsetting[] = "$6$rounds=1234$abc0123456789$";
+	static const char testhash[] = "$6$rounds=1234$abc0123456789$BCpt8zLrc/RcyuXmCDOE1ALqMXB2MH6n1g891HhFj8.w7LxGv.FTkqq6Vxc/km3Y0jE0j24jY5PIv/oOu6reg1";
+	char testbuf[128];
+	char *p, *q;
+
+	p = sha512crypt(key, setting, output);
+	/* self test and stack cleanup */
+	q = sha512crypt(testkey, testsetting, testbuf);
+	if (!p || q != testbuf || memcmp(testbuf, testhash, sizeof testhash))
+		return "*";
+	return p;
+}