tiger: added tiger192 hash func

src/algorithm.h

@@ -37,6 +37,9 @@ class algorithm
 public:
 	virtual bool provides_signatures() = 0;
 	virtual bool provides_encryption() = 0;
+
+	// virtual bool provides_identification() = 0; // TODO
+
 	virtual std::string get_alg_id() = 0;
 
 	void register_into_suite (algorithm_suite&s) {

src/tiger.h

@@ -0,0 +1,148 @@
+/**
+ * Copyright (c) 2012 Francisco Blas Izquierdo Riera (klondike)
+ * The Tiger algorithm was written by Eli Biham and Ross Anderson and is
+ * available on the official Tiger algorithm page.
+ * 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,
+ *    the algorithm authorsip 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.
+ * 4. If this license is not appropriate for you please write me at
+ *    klondike ( a t ) klondike ( d o t ) es to negotiate another license.
+ *
+ * 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.
+ **/
+
+/**
+ * These are some implementations of tiger made without looking at the original
+ * reference code to ensure the resulting code can be published under a free
+ * license. The paper was looked though to know how did tiger work.
+ */
+
+/** Implementation details:
+ * * Here we assume char and unsigned char have size 1. If thats not the case in
+ *     your compiler you may want to replace them by a type that does
+ */
+
+#ifndef TIGER_H
+#define TIGER_H 1
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#if !defined(_MSC_VER) || (_MSC_VER >= 1600)
+#include <stdint.h>
+#else
+
+typedef __int32 int32_t;
+typedef unsigned __int32 uint32_t;
+typedef __int64 int64_t;
+typedef unsigned __int64 uint64_t;
+
+#endif
+
+#if _M_IX86_FP >= 2
+#define __SSE2__
+#endif
+
+#ifdef __linux
+#include <endian.h>
+#if __BYTE_ORDER == __LITTLE_ENDIAN
+#define IS_LITTLE_ENDIAN
+#elif  __BYTE_ORDER == __BIG_ENDIAN
+#define USE_BIG_ENDIAN
+#elif  __BYTE_ORDER == __PDP_ENDIAN
+#error "If you feel like writting code for PDP endianess go ahead, I'm not doing that"
+#else
+#error "Unknown endianess"
+#endif
+#else
+//Assume little endian if you know how to detect endianism well on other
+//compilers state it.
+#define IS_LITTLE_ENDIAN
+#endif
+
+#if defined(_WIN64) || defined(__x86_64__) || defined(__amd64__)
+#define HASX64
+#endif
+
+
+/** A word in the tiger hash, 64 bits **/
+typedef uint64_t t_word;
+
+/** This one is provided as a commodity for people wanting an easy way to
+ * declare result variables **/
+typedef t_word t_res[3];
+
+/** Partial calculation as used by tigerp1 and tigerp2 **/
+typedef struct {
+	t_res h; // Hash status
+	char r[128]; // SALT
+	t_word n; // Number of characters of r used
+	t_word hs; // Amount of total data hashed
+} t_pres;
+
+/** This one is provided as a commodity for people wanting an easy way to
+ * declare block variables **/
+typedef t_word t_block[8];
+
+/** Standard tiger calculation, put your string in str and the string length on length and get the result on res **/
+void tiger (const char *str, t_word length, t_res res);
+/** Similar to tiger but interleaving accesses to both equally sized strings to
+ * reduce overhead and pipeline stalls you get the result of str1 on res1 and
+ * the one of str2 on res2 **/
+void tiger_2 (const char *str1, const char *str2, t_word length,
+              t_res res1, t_res res2);
+#ifdef __SSE2__
+/** This is equivalent to tiger_2 but uses SSE2 for the key schduling making it
+ * faster **/
+void tiger_sse2 (const char *str1, const char *str2, t_word length, t_res res1, t_res res2);
+#endif
+/** This function is optimized for use on TTHs just send the two concatenated
+ * hashes and you will get back the hash with a prepended 0x01 **/
+void tiger_49 (const char *str, t_res res);
+/** This function is optimized for use on TTHs just send the 1024 sized block
+ * and you will get back the hash with a prepended 0x00 **/
+void tiger_1025 (const char *str, t_res res);
+/** Interleaved version of tiger_49 you insert two hashes and get back two
+ * results **/
+void tiger_2_49 (const char *str1, const char *str2, t_res res1, t_res res2);
+/** Interleaved version of tiger_1025 you insert two hashes and get back two
+ * results **/
+void tiger_2_1025 (const char *str1, const char *str2, t_res res1, t_res res2);
+#ifdef __SSE2__
+/** SSE2 version of tiger_49 you insert two hashes and get back two results **/
+void tiger_sse2_49 (const char *str1, const char *str2, t_res res1, t_res res2);
+/** SSE2 version of tiger_1025 you insert two hashes and get back two results
+ * **/
+void tiger_sse2_1025 (const char *str1, const char *str2,
+                      t_res res1, t_res res2);
+#endif
+/** First stage of partial tiger calculation to improve password security
+ * during storage **/
+void tigerp1 (const char *password, t_word length, const char *salt,
+              t_pres *pres);
+/** Second stage of partial tiger calculation **/
+void tigerp2 (const t_pres *pres, const char *salt, t_word length, t_res res);
+
+#ifdef __cplusplus
+}  //extern "C"
+#endif
+
+#endif

src/tiger_hash.h

@@ -0,0 +1,41 @@
+
+
+/*
+ * This file is part of Codecrypt.
+ *
+ * Codecrypt is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or (at
+ * your option) any later version.
+ *
+ * Codecrypt 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 Lesser General Public
+ * License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with Codecrypt. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef _ccr_tiger_hash_h_
+#define _ccr_tiger_hash_h_
+
+#include "hash.h"
+#include "tiger.h"
+
+class tiger192hash : public hash_func
+{
+public:
+	uint size() {
+		return 24;
+	}
+
+	std::vector<byte> operator() (const std::vector<byte>&a) {
+		std::vector<byte> r;
+		r.resize (size() );
+		tiger ( (const char*) & (a[0]), a.size(), (t_word*) & (r[0]) );
+		return r;
+	}
+};
+
+#endif