Menu
▾
▴
[Pmplib-commits] SF.net SVN: pmplib: [414] trunk/pmplib/lib/pmp_ipod
|
From: <ny...@us...> - 2007-09-17 13:00:29
|
Revision: 414
http://pmplib.svn.sourceforge.net/pmplib/?rev=414&view=rev
Author: nyaochi
Date: 2007-09-17 06:00:32 -0700 (Mon, 17 Sep 2007)
Log Message:
-----------
Supported iPod nano 3rd gen. Many thanks go to those
who analyzed the algorithm to compute the hash value in
"mhbd" chunk, especially wtbw, nopcode, retar_d,
oleavr, and desrt at #gtkpod.
Other new iPod models are not supported at this moment
due to the lack of the code to obtain the serial string
on USB devices.
Modified Paths:
--------------
trunk/pmplib/lib/pmp_ipod/ipod.c
trunk/pmplib/lib/pmp_ipod/itunesdb.c
trunk/pmplib/lib/pmp_ipod/itunesdb.h
trunk/pmplib/lib/pmp_ipod/pmp_ipod.vcproj
Added Paths:
-----------
trunk/pmplib/lib/pmp_ipod/hash58.c
trunk/pmplib/lib/pmp_ipod/hash58.h
trunk/pmplib/lib/pmp_ipod/sha1.c
trunk/pmplib/lib/pmp_ipod/sha1.h
Added: trunk/pmplib/lib/pmp_ipod/hash58.c
===================================================================
--- trunk/pmplib/lib/pmp_ipod/hash58.c (rev 0)
+++ trunk/pmplib/lib/pmp_ipod/hash58.c 2007-09-17 13:00:32 UTC (rev 414)
@@ -0,0 +1,173 @@
+/*
+SHA1 hash value generator for offset 0x58 of "mhbd" chunk.
+
+This source code is taken from the implementation at:
+http://main.wtbw.co.uk/hash58.zip
+
+Many thanks to those who involved in the analysis at #gtkpod
+(wtbw, nopcode, retar_d, oleavr, desrt)
+*/
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif/*HAVE_CONFIG_H*/
+
+#include <os.h>
+#include <memory.h>
+#include "sha1.h"
+
+#define MIN2(a, b) ((a) < (b) ? (a) : (b))
+
+unsigned char invTable[256] = {
+ 0x74, 0x85, 0x96, 0xA7, 0xB8, 0xC9, 0xDA, 0xEB, 0xFC, 0x0D, 0x1E, 0x2F, 0x40, 0x51, 0x62, 0x73,
+ 0x84, 0x95, 0xA6, 0xB7, 0xC8, 0xD9, 0xEA, 0xFB, 0x0C, 0x1D, 0x2E, 0x3F, 0x50, 0x61, 0x72, 0x83,
+ 0x94, 0xA5, 0xB6, 0xC7, 0xD8, 0xE9, 0xFA, 0x0B, 0x1C, 0x2D, 0x3E, 0x4F, 0x60, 0x71, 0x82, 0x93,
+ 0xA4, 0xB5, 0xC6, 0xD7, 0xE8, 0xF9, 0x0A, 0x1B, 0x2C, 0x3D, 0x4E, 0x5F, 0x70, 0x81, 0x92, 0xA3,
+ 0xB4, 0xC5, 0xD6, 0xE7, 0xF8, 0x09, 0x1A, 0x2B, 0x3C, 0x4D, 0x5E, 0x6F, 0x80, 0x91, 0xA2, 0xB3,
+ 0xC4, 0xD5, 0xE6, 0xF7, 0x08, 0x19, 0x2A, 0x3B, 0x4C, 0x5D, 0x6E, 0x7F, 0x90, 0xA1, 0xB2, 0xC3,
+ 0xD4, 0xE5, 0xF6, 0x07, 0x18, 0x29, 0x3A, 0x4B, 0x5C, 0x6D, 0x7E, 0x8F, 0xA0, 0xB1, 0xC2, 0xD3,
+ 0xE4, 0xF5, 0x06, 0x17, 0x28, 0x39, 0x4A, 0x5B, 0x6C, 0x7D, 0x8E, 0x9F, 0xB0, 0xC1, 0xD2, 0xE3,
+ 0xF4, 0x05, 0x16, 0x27, 0x38, 0x49, 0x5A, 0x6B, 0x7C, 0x8D, 0x9E, 0xAF, 0xC0, 0xD1, 0xE2, 0xF3,
+ 0x04, 0x15, 0x26, 0x37, 0x48, 0x59, 0x6A, 0x7B, 0x8C, 0x9D, 0xAE, 0xBF, 0xD0, 0xE1, 0xF2, 0x03,
+ 0x14, 0x25, 0x36, 0x47, 0x58, 0x69, 0x7A, 0x8B, 0x9C, 0xAD, 0xBE, 0xCF, 0xE0, 0xF1, 0x02, 0x13,
+ 0x24, 0x35, 0x46, 0x57, 0x68, 0x79, 0x8A, 0x9B, 0xAC, 0xBD, 0xCE, 0xDF, 0xF0, 0x01, 0x12, 0x23,
+ 0x34, 0x45, 0x56, 0x67, 0x78, 0x89, 0x9A, 0xAB, 0xBC, 0xCD, 0xDE, 0xEF, 0x00, 0x11, 0x22, 0x33,
+ 0x44, 0x55, 0x66, 0x77, 0x88, 0x99, 0xAA, 0xBB, 0xCC, 0xDD, 0xEE, 0xFF, 0x10, 0x21, 0x32, 0x43,
+ 0x54, 0x65, 0x76, 0x87, 0x98, 0xA9, 0xBA, 0xCB, 0xDC, 0xED, 0xFE, 0x0F, 0x20, 0x31, 0x42, 0x53,
+ 0x64, 0x75, 0x86, 0x97, 0xA8, 0xB9, 0xCA, 0xDB, 0xEC, 0xFD, 0x0E, 0x1F, 0x30, 0x41, 0x52, 0x63
+};
+
+unsigned char table1[256] = {
+ 0x3A, 0x3F, 0x3E, 0x72, 0xBD, 0xA2, 0xD6, 0xB4, 0x63, 0xC0, 0x6E, 0x62, 0x59, 0x1E, 0xE2, 0x71,
+ 0xB5, 0x0D, 0xE8, 0x0C, 0x25, 0x38, 0xCE, 0x23, 0x7C, 0xB7, 0xAD, 0x16, 0xDF, 0x47, 0x3D, 0xB3,
+ 0x7E, 0x8C, 0xAA, 0x61, 0x31, 0x66, 0xBE, 0x4F, 0x97, 0x14, 0x54, 0xF0, 0x70, 0xEB, 0x30, 0xC4,
+ 0x27, 0x4E, 0xFA, 0x1A, 0x2B, 0x11, 0xF4, 0x45, 0x8E, 0x5D, 0x73, 0xED, 0x22, 0x2E, 0x7D, 0xA4,
+ 0x28, 0xDA, 0x2F, 0xC5, 0x92, 0x09, 0x05, 0x13, 0x9D, 0x32, 0x51, 0x4A, 0xC8, 0xBA, 0x96, 0xA7,
+ 0x6A, 0x50, 0xF3, 0xBC, 0x93, 0xBF, 0xB0, 0xD2, 0xD5, 0x82, 0x19, 0x98, 0x35, 0xCF, 0x6B, 0xB6,
+ 0x83, 0x56, 0x15, 0xF2, 0x9A, 0x9C, 0xCA, 0x74, 0x34, 0x58, 0x8D, 0xA6, 0x03, 0xFF, 0x46, 0x7B,
+ 0xD0, 0x7A, 0x33, 0x76, 0xDD, 0xAC, 0xCB, 0x24, 0x7F, 0xB1, 0x85, 0x60, 0xC3, 0x26, 0x8A, 0x1D,
+ 0x1C, 0x8F, 0x2A, 0xEF, 0x06, 0xDE, 0x67, 0x5E, 0xE7, 0xAE, 0xD9, 0xCC, 0x07, 0x6C, 0xF8, 0x0A,
+ 0xD3, 0x40, 0x36, 0x1F, 0x2D, 0x95, 0x43, 0xDB, 0x01, 0x89, 0x4B, 0xF7, 0xB9, 0x39, 0xC2, 0x52,
+ 0x53, 0xFD, 0x65, 0xF5, 0x68, 0xC1, 0xC7, 0x9F, 0x4D, 0xEA, 0xAF, 0x6D, 0x10, 0x44, 0x87, 0xD8,
+ 0xEE, 0x1B, 0xFE, 0x3C, 0xDC, 0x84, 0x69, 0x48, 0x6F, 0xD1, 0x57, 0x55, 0xD4, 0xA5, 0x49, 0x5B,
+ 0xE5, 0x0B, 0x94, 0xC9, 0x5F, 0xE1, 0x17, 0x81, 0xBB, 0xEC, 0xD7, 0xC6, 0x02, 0x4C, 0x42, 0x75,
+ 0xA3, 0x99, 0xE4, 0xA1, 0x9B, 0x5A, 0xF1, 0x29, 0xA0, 0x64, 0x9E, 0x18, 0x41, 0x80, 0x2C, 0x79,
+ 0x20, 0x8B, 0xAB, 0x90, 0x08, 0xB8, 0xA9, 0x77, 0x12, 0xF9, 0x0E, 0x88, 0xE9, 0x04, 0xFB, 0x86,
+ 0x0F, 0xE0, 0xA8, 0x5C, 0xE6, 0x21, 0xCD, 0x3B, 0x00, 0x78, 0xFC, 0xF6, 0xE3, 0x37, 0xB2, 0x91
+};
+
+unsigned char table2[256] = {
+ 0xF3, 0xE4, 0x1B, 0x38, 0xE5, 0x6F, 0xE8, 0x9D, 0x3E, 0x55, 0xBA, 0xC7, 0xAC, 0xEA, 0x66, 0xA2,
+ 0xB9, 0x7A, 0x34, 0x43, 0x02, 0x4E, 0xFE, 0x36, 0x41, 0x57, 0x1A, 0xB1, 0x31, 0x87, 0x04, 0x52,
+ 0x21, 0x22, 0xE1, 0x13, 0x7F, 0x03, 0x3A, 0x90, 0xF7, 0x69, 0x78, 0x12, 0x83, 0x0B, 0x9A, 0x97,
+ 0x4D, 0xB7, 0x8C, 0xBF, 0x2D, 0x94, 0xD1, 0x93, 0x2F, 0x42, 0x23, 0xA4, 0xE0, 0x92, 0xDC, 0x68,
+ 0xD3, 0xDD, 0xAF, 0x91, 0x9F, 0xED, 0x3D, 0x8F, 0xA1, 0x51, 0xD9, 0xE9, 0x70, 0x28, 0xEF, 0xB3,
+ 0x49, 0xA5, 0x0D, 0xC5, 0xD0, 0x60, 0xB4, 0x2B, 0x07, 0xF8, 0xDF, 0xE6, 0x16, 0xC0, 0x30, 0x71,
+ 0x85, 0xFD, 0x72, 0x95, 0x29, 0x79, 0x0A, 0x7B, 0x46, 0x11, 0x7D, 0x88, 0x1D, 0x2A, 0x48, 0x1F,
+ 0x45, 0x89, 0x47, 0xEE, 0xBB, 0xBE, 0x6E, 0xC3, 0x6C, 0xCE, 0x10, 0x5A, 0x2C, 0xCA, 0xFB, 0xB2,
+ 0xCB, 0x1C, 0x9C, 0xEC, 0x2E, 0x56, 0x59, 0x9B, 0xA6, 0x53, 0xAE, 0x17, 0x25, 0xC1, 0x3F, 0x6A,
+ 0x0F, 0x09, 0x01, 0xA3, 0xD6, 0xA0, 0xD8, 0x08, 0xE3, 0x74, 0x06, 0x6D, 0x19, 0x98, 0x1E, 0x77,
+ 0x76, 0xBC, 0xEB, 0x3C, 0xB0, 0xC4, 0xC8, 0x64, 0x0E, 0x86, 0x63, 0xD7, 0xDB, 0xBD, 0xA7, 0x82,
+ 0x39, 0x4F, 0x27, 0xD2, 0x5F, 0x73, 0xF4, 0x75, 0x6B, 0xC2, 0xD5, 0x67, 0x5D, 0x80, 0xAB, 0x81,
+ 0xDE, 0xF0, 0xAD, 0xAA, 0xCD, 0xB6, 0xF6, 0x7C, 0xFC, 0x33, 0x05, 0x14, 0x96, 0x15, 0xC9, 0x9E,
+ 0x35, 0x5C, 0x7E, 0x44, 0x54, 0x58, 0x3B, 0x40, 0x20, 0xA8, 0x8B, 0x5E, 0x4A, 0x24, 0x99, 0x8E,
+ 0xF5, 0xB5, 0x62, 0x00, 0x37, 0x5B, 0x18, 0x65, 0x8D, 0x32, 0xE2, 0xF9, 0xDA, 0x8A, 0xD4, 0xCC,
+ 0x26, 0xF2, 0xF1, 0xE7, 0x4B, 0xC6, 0xCF, 0xFF, 0x4C, 0x84, 0x61, 0xFA, 0xB8, 0x0C, 0xA9, 0x50
+};
+
+unsigned char fixed[18] = {
+ 0x67, 0x23, 0xFE, 0x30, 0x45, 0x33, 0xF8, 0x90, 0x99, 0x21, 0x07, 0xC1, 0xD0, 0x12, 0xB2, 0xA1, 0x07, 0x81
+};
+
+int GCD(int a, int b){
+ while( 1 )
+ {
+ a = a % b;
+ if( a == 0 )
+ return b;
+ b = b % a;
+ if( b == 0 )
+ return a;
+ }
+}
+
+int LCM(int a, int b)
+{
+ if(a==0 || b==0)
+ return 1;
+
+ return (a*b)/GCD(a,b);
+}
+
+
+//pFWID -> 8 bytes
+//pKey -> 64 byte buffer
+void GenerateKey(unsigned char *pFWID, unsigned char *pKey)
+{
+ int i;
+ SHA1_CTX context;
+ unsigned char y[16];
+
+ memset(pKey,0, 64);
+
+ //take LCM of each two bytes in the FWID in turn
+ for(i=0;i<4;i++){
+ int a=pFWID[i*2];
+ int b=pFWID[i*2+1];
+ int lcm = LCM(a,b);
+
+ unsigned char hi = (lcm & 0xFF00) >> 8;
+ unsigned char lo = lcm & 0xFF;
+
+ y[i*4] = ((table1[hi] * 0xB5) - 3);
+ y[i*4 + 1] = ((table2[hi] * 0xB7) + 0x49);
+ y[i*4 + 2] = ((table1[lo] * 0xB5) - 3);
+ y[i*4 + 3] = ((table2[lo] * 0xB7) + 0x49);
+ }
+
+ //convert y
+ for(i=0;i<16;i++){
+ y[i] = invTable[y[i]];
+ }
+
+ //hash
+ SHA1Init(&context);
+ SHA1Update(&context, fixed, 18);
+ SHA1Update(&context, y, 16);
+ SHA1Final(pKey, &context);
+}
+
+#define SIZE_OF_HEADERS 0x6C
+
+//pDataBase -> iTunesDB
+//pFWID -> 8 bytes
+//pHash -> 20 byte buffer
+void GenerateHash(uint8_t *pFWID, uint8_t *pDataBase, size_t lSize, uint8_t *pHash)
+{
+ int i;
+ SHA1_CTX context;
+ unsigned char key[64];
+ size_t lSizeWithoutHeaders = lSize - SIZE_OF_HEADERS;
+ size_t lSizeToUse = MIN2((long)0x40000, lSizeWithoutHeaders) + SIZE_OF_HEADERS;
+
+ //generate invtable
+ GenerateKey(pFWID, key);
+
+ //hmac sha1
+ for (i=0; i < 64; i++)
+ key[i] ^= 0x36;
+
+
+ SHA1Init(&context);
+ SHA1Update(&context, key, 64);
+ SHA1Update(&context, pDataBase, lSizeToUse);
+ SHA1Final(pHash, &context);
+
+ for (i=0; i < 64; i++)
+ key[i] ^= 0x36 ^ 0x5c;
+
+ SHA1Init(&context);
+ SHA1Update(&context, key, 64);
+ SHA1Update(&context, pHash, 20);
+ SHA1Final(pHash, &context);
+}
Added: trunk/pmplib/lib/pmp_ipod/hash58.h
===================================================================
--- trunk/pmplib/lib/pmp_ipod/hash58.h (rev 0)
+++ trunk/pmplib/lib/pmp_ipod/hash58.h 2007-09-17 13:00:32 UTC (rev 414)
@@ -0,0 +1,6 @@
+#ifndef __HASH58_H__
+#define __HASH58_H__
+
+void GenerateHash(uint8_t *pFWID, uint8_t *pDataBase, size_t lSize, uint8_t *pHash);
+
+#endif/*__HASH58_H__*/
Modified: trunk/pmplib/lib/pmp_ipod/ipod.c
===================================================================
--- trunk/pmplib/lib/pmp_ipod/ipod.c 2007-09-17 12:14:30 UTC (rev 413)
+++ trunk/pmplib/lib/pmp_ipod/ipod.c 2007-09-17 13:00:32 UTC (rev 414)
@@ -248,6 +248,9 @@
fp = ucs2fopen(itunesdb, "wb");
if (fp) {
+ /* Finalize the database (fill the hash58 value). */
+ itunesdb_finalize(sio.base, sio.offset);
+
if (fwrite(sio.base, 1, sio.offset, fp) != sio.offset) {
return (IPODC_ITUNESDB|IPODE_FILEWRITEERROR);
}
Modified: trunk/pmplib/lib/pmp_ipod/itunesdb.c
===================================================================
--- trunk/pmplib/lib/pmp_ipod/itunesdb.c 2007-09-17 12:14:30 UTC (rev 413)
+++ trunk/pmplib/lib/pmp_ipod/itunesdb.c 2007-09-17 13:00:32 UTC (rev 414)
@@ -38,9 +38,9 @@
#include "serialize.h"
#include "util.h"
#include "itunesdb.h"
+#include "hash58.h"
-
static void chunk_finish(itunesdb_chunk_t* chunk)
{
free(chunk->data);
@@ -989,6 +989,31 @@
return 0;
}
+int itunesdb_finalize(uint8_t* buffer, size_t size)
+{
+ uint8_t* src = NULL;
+ uint8_t hash58[20];
+ uint8_t fwid[8] = {
+ 0x00, 0x0A, 0x27, 0x00, 0x1A, 0x1D, 0x72, 0xF1
+ }; /* iPod nano 3rd gen only for now. */
+
+ src = (uint8_t*)malloc(size);
+ if (src == NULL) {
+ return 1;
+ }
+ memcpy(src, buffer, size);
+
+ memset(src+0x18, 0, 8);
+ memset(src+0x32, 0, 20);
+ memset(src+0x58, 0, 20);
+ GenerateHash(fwid, src, size, hash58);
+ free(src);
+
+ memcpy(buffer+0x58, hash58, sizeof(hash58));
+ return 0;
+}
+
+
itunesdb_chunk_t* itunesdb_new_child(itunesdb_chunk_t* chunk)
{
chunk->childlen = (itunesdb_chunk_t*)realloc(
Modified: trunk/pmplib/lib/pmp_ipod/itunesdb.h
===================================================================
--- trunk/pmplib/lib/pmp_ipod/itunesdb.h 2007-09-17 12:14:30 UTC (rev 413)
+++ trunk/pmplib/lib/pmp_ipod/itunesdb.h 2007-09-17 13:00:32 UTC (rev 414)
@@ -332,5 +332,6 @@
int itunesdb_repr(itunesdb_chunk_t* chunk, size_t index, serializer_t* sio);
int itunesdb_read(itunesdb_chunk_t* chunk, serializer_t* sio);
int itunesdb_write(itunesdb_chunk_t* chunk, serializer_t* sio);
+int itunesdb_finalize(uint8_t* buffer, size_t size);
#endif/*__ITUNESDB_H__*/
Modified: trunk/pmplib/lib/pmp_ipod/pmp_ipod.vcproj
===================================================================
--- trunk/pmplib/lib/pmp_ipod/pmp_ipod.vcproj 2007-09-17 12:14:30 UTC (rev 413)
+++ trunk/pmplib/lib/pmp_ipod/pmp_ipod.vcproj 2007-09-17 13:00:32 UTC (rev 414)
@@ -179,6 +179,10 @@
UniqueIdentifier="{4FC737F1-C7A5-4376-A066-2A32D752A2FF}"
>
<File
+ RelativePath=".\hash58.c"
+ >
+ </File>
+ <File
RelativePath=".\ipod.c"
>
</File>
@@ -199,6 +203,10 @@
>
</File>
<File
+ RelativePath=".\sha1.c"
+ >
+ </File>
+ <File
RelativePath=".\util.c"
>
</File>
@@ -209,6 +217,10 @@
UniqueIdentifier="{93995380-89BD-4b04-88EB-625FBE52EBFB}"
>
<File
+ RelativePath=".\hash58.h"
+ >
+ </File>
+ <File
RelativePath=".\ipod.h"
>
</File>
@@ -229,6 +241,10 @@
>
</File>
<File
+ RelativePath=".\sha1.h"
+ >
+ </File>
+ <File
RelativePath=".\status.h"
>
</File>
Added: trunk/pmplib/lib/pmp_ipod/sha1.c
===================================================================
--- trunk/pmplib/lib/pmp_ipod/sha1.c (rev 0)
+++ trunk/pmplib/lib/pmp_ipod/sha1.c 2007-09-17 13:00:32 UTC (rev 414)
@@ -0,0 +1,245 @@
+/*
+SHA-1 in C
+By Steve Reid <st...@ed...>
+100% Public Domain
+
+Test Vectors (from FIPS PUB 180-1)
+"abc"
+A9993E36 4706816A BA3E2571 7850C26C 9CD0D89D
+"abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq"
+84983E44 1C3BD26E BAAE4AA1 F95129E5 E54670F1
+A million repetitions of "a"
+34AA973C D4C4DAA4 F61EEB2B DBAD2731 6534016F
+*/
+
+#define LITTLE_ENDIAN /* This should be #define'd if true. */
+/* #define SHA1HANDSOFF * Copies data before messing with it. */
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif/*HAVE_CONFIG_H*/
+
+#include <os.h>
+#include <stdio.h>
+#include <string.h>
+
+typedef struct {
+ unsigned long state[5];
+ unsigned long count[2];
+ unsigned char buffer[64];
+} SHA1_CTX;
+
+void SHA1Transform(unsigned long state[5], unsigned char buffer[64]);
+void SHA1Init(SHA1_CTX* context);
+void SHA1Update(SHA1_CTX* context, unsigned char* data, unsigned int len);
+void SHA1Final(unsigned char digest[20], SHA1_CTX* context);
+
+#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits))))
+
+/* blk0() and blk() perform the initial expand. */
+/* I got the idea of expanding during the round function from SSLeay */
+#ifdef LITTLE_ENDIAN
+#define blk0(i) (block->l[i] = (rol(block->l[i],24)&0xFF00FF00) \
+ |(rol(block->l[i],8)&0x00FF00FF))
+#else
+#define blk0(i) block->l[i]
+#endif
+#define blk(i) (block->l[i&15] = rol(block->l[(i+13)&15]^block->l[(i+8)&15] \
+ ^block->l[(i+2)&15]^block->l[i&15],1))
+
+/* (R0+R1), R2, R3, R4 are the different operations used in SHA1 */
+#define R0(v,w,x,y,z,i) z+=((w&(x^y))^y)+blk0(i)+0x5A827999+rol(v,5);w=rol(w,30);
+#define R1(v,w,x,y,z,i) z+=((w&(x^y))^y)+blk(i)+0x5A827999+rol(v,5);w=rol(w,30);
+#define R2(v,w,x,y,z,i) z+=(w^x^y)+blk(i)+0x6ED9EBA1+rol(v,5);w=rol(w,30);
+#define R3(v,w,x,y,z,i) z+=(((w|x)&y)|(w&x))+blk(i)+0x8F1BBCDC+rol(v,5);w=rol(w,30);
+#define R4(v,w,x,y,z,i) z+=(w^x^y)+blk(i)+0xCA62C1D6+rol(v,5);w=rol(w,30);
+
+/* Hash a single 512-bit block. This is the core of the algorithm. */
+
+void SHA1Transform(unsigned long state[5], unsigned char buffer[64])
+{
+ unsigned long a, b, c, d, e;
+ typedef union {
+ unsigned char c[64];
+ unsigned long l[16];
+ } CHAR64LONG16;
+ CHAR64LONG16* block;
+
+ /*
+ printf("SHA1Transform:\n");
+ for (k = 0; k < 4; k++) {
+ for (i = 0; i < 4; i++) {
+ for (j = 0; j < 4; j++) {
+ printf("%02X", buffer[k*16+i*4+j]);
+ }
+ putchar(' ');
+ }
+ putchar('\n');
+ }
+ printf("SHA1Transform (translated):\n");
+ for (k = 0; k < 4; k++) {
+ for (i = 0; i < 4; i++) {
+ for (j = 0; j < 4; j++) {
+ long x = buffer[k*16+i*4+j] & 0xFF;
+ printf("%02X", cryptTable[x] & 0xFF);
+ }
+ putchar(' ');
+ }
+ putchar('\n');
+ }
+ */
+
+#ifdef SHA1HANDSOFF
+ static unsigned char workspace[64];
+ block = (CHAR64LONG16*)workspace;
+ memcpy(block, buffer, 64);
+#else
+ block = (CHAR64LONG16*)buffer;
+#endif
+ /* Copy context->state[] to working vars */
+ a = state[0];
+ b = state[1];
+ c = state[2];
+ d = state[3];
+ e = state[4];
+ /* 4 rounds of 20 operations each. Loop unrolled. */
+ R0(a,b,c,d,e, 0); R0(e,a,b,c,d, 1); R0(d,e,a,b,c, 2); R0(c,d,e,a,b, 3);
+ R0(b,c,d,e,a, 4); R0(a,b,c,d,e, 5); R0(e,a,b,c,d, 6); R0(d,e,a,b,c, 7);
+ R0(c,d,e,a,b, 8); R0(b,c,d,e,a, 9); R0(a,b,c,d,e,10); R0(e,a,b,c,d,11);
+ R0(d,e,a,b,c,12); R0(c,d,e,a,b,13); R0(b,c,d,e,a,14); R0(a,b,c,d,e,15);
+ R1(e,a,b,c,d,16); R1(d,e,a,b,c,17); R1(c,d,e,a,b,18); R1(b,c,d,e,a,19);
+ R2(a,b,c,d,e,20); R2(e,a,b,c,d,21); R2(d,e,a,b,c,22); R2(c,d,e,a,b,23);
+ R2(b,c,d,e,a,24); R2(a,b,c,d,e,25); R2(e,a,b,c,d,26); R2(d,e,a,b,c,27);
+ R2(c,d,e,a,b,28); R2(b,c,d,e,a,29); R2(a,b,c,d,e,30); R2(e,a,b,c,d,31);
+ R2(d,e,a,b,c,32); R2(c,d,e,a,b,33); R2(b,c,d,e,a,34); R2(a,b,c,d,e,35);
+ R2(e,a,b,c,d,36); R2(d,e,a,b,c,37); R2(c,d,e,a,b,38); R2(b,c,d,e,a,39);
+ R3(a,b,c,d,e,40); R3(e,a,b,c,d,41); R3(d,e,a,b,c,42); R3(c,d,e,a,b,43);
+ R3(b,c,d,e,a,44); R3(a,b,c,d,e,45); R3(e,a,b,c,d,46); R3(d,e,a,b,c,47);
+ R3(c,d,e,a,b,48); R3(b,c,d,e,a,49); R3(a,b,c,d,e,50); R3(e,a,b,c,d,51);
+ R3(d,e,a,b,c,52); R3(c,d,e,a,b,53); R3(b,c,d,e,a,54); R3(a,b,c,d,e,55);
+ R3(e,a,b,c,d,56); R3(d,e,a,b,c,57); R3(c,d,e,a,b,58); R3(b,c,d,e,a,59);
+ R4(a,b,c,d,e,60); R4(e,a,b,c,d,61); R4(d,e,a,b,c,62); R4(c,d,e,a,b,63);
+ R4(b,c,d,e,a,64); R4(a,b,c,d,e,65); R4(e,a,b,c,d,66); R4(d,e,a,b,c,67);
+ R4(c,d,e,a,b,68); R4(b,c,d,e,a,69); R4(a,b,c,d,e,70); R4(e,a,b,c,d,71);
+ R4(d,e,a,b,c,72); R4(c,d,e,a,b,73); R4(b,c,d,e,a,74); R4(a,b,c,d,e,75);
+ R4(e,a,b,c,d,76); R4(d,e,a,b,c,77); R4(c,d,e,a,b,78); R4(b,c,d,e,a,79);
+ /* Add the working vars back into context.state[] */
+ state[0] += a;
+ state[1] += b;
+ state[2] += c;
+ state[3] += d;
+ state[4] += e;
+ /* Wipe variables */
+ a = b = c = d = e = 0;
+}
+
+
+/* SHA1Init - Initialize new context */
+
+void SHA1Init(SHA1_CTX* context)
+{
+ /* SHA1 initialization constants */
+ context->state[0] = 0x67452301;
+ context->state[1] = 0xEFCDAB89;
+ context->state[2] = 0x98BADCFE;
+ context->state[3] = 0x10325476;
+ context->state[4] = 0xC3D2E1F0;
+ context->count[0] = context->count[1] = 0;
+}
+
+
+/* Run your data through this. */
+
+void SHA1Update(SHA1_CTX* context, unsigned char* data, unsigned int len)
+{
+ unsigned int i, j;
+
+ j = (context->count[0] >> 3) & 63;
+ if ((context->count[0] += len << 3) < (len << 3)) context->count[1]++;
+ context->count[1] += (len >> 29);
+ if ((j + len) > 63) {
+ memcpy(&context->buffer[j], data, (i = 64-j));
+ SHA1Transform(context->state, context->buffer);
+ for ( ; i + 63 < len; i += 64) {
+ SHA1Transform(context->state, &data[i]);
+ }
+ j = 0;
+ }
+ else i = 0;
+ memcpy(&context->buffer[j], &data[i], len - i);
+}
+
+
+/* Add padding and return the message digest. */
+
+void SHA1Final(unsigned char digest[20], SHA1_CTX* context)
+{
+ unsigned long i, j;
+ unsigned char finalcount[8];
+
+ for (i = 0; i < 8; i++) {
+ finalcount[i] = (unsigned char)((context->count[(i >= 4 ? 0 : 1)]
+ >> ((3-(i & 3)) * 8) ) & 255); /* Endian independent */
+ }
+ SHA1Update(context, (unsigned char *)"\200", 1);
+ while ((context->count[0] & 504) != 448) {
+ SHA1Update(context, (unsigned char *)"\0", 1);
+ }
+ SHA1Update(context, finalcount, 8); /* Should cause a SHA1Transform() */
+ for (i = 0; i < 20; i++) {
+ digest[i] = (unsigned char)
+ ((context->state[i>>2] >> ((3-(i & 3)) * 8) ) & 255);
+ }
+ /* Wipe variables */
+ i = j = 0;
+ memset(context->buffer, 0, 64);
+ memset(context->state, 0, 20);
+ memset(context->count, 0, 8);
+ memset(&finalcount, 0, 8);
+#ifdef SHA1HANDSOFF /* make SHA1Transform overwrite it's own static vars */
+ SHA1Transform(context->state, context->buffer);
+#endif
+}
+
+
+/*************************************************************/
+
+/*
+int main(int argc, char** argv)
+{
+ int i, j;
+ SHA1_CTX context;
+ unsigned char digest[20], buffer[16384];
+ FILE* file;
+
+ if (argc > 2) {
+ puts("Public domain SHA-1 implementation - by Steve Reid <st...@ed...>");
+ puts("Produces the SHA-1 hash of a file, or stdin if no file is specified.");
+ exit(0);
+ }
+ if (argc < 2) {
+ file = stdin;
+ }
+ else {
+ if (!(file = fopen(argv[1], "rb"))) {
+ fputs("Unable to open file.", stderr);
+ exit(-1);
+ }
+ }
+ SHA1Init(&context);
+ while (!feof(file)) { /* note: what if ferror(file)
+ i = fread(buffer, 1, 16384, file);
+ SHA1Update(&context, buffer, i);
+ }
+ SHA1Final(digest, &context);
+ fclose(file);
+ for (i = 0; i < 5; i++) {
+ for (j = 0; j < 4; j++) {
+ printf("%02X", digest[i*4+j]);
+ }
+ putchar(' ');
+ }
+ putchar('\n');
+ exit(0);
+}
+*/
Added: trunk/pmplib/lib/pmp_ipod/sha1.h
===================================================================
--- trunk/pmplib/lib/pmp_ipod/sha1.h (rev 0)
+++ trunk/pmplib/lib/pmp_ipod/sha1.h 2007-09-17 13:00:32 UTC (rev 414)
@@ -0,0 +1,13 @@
+#ifndef __SHA1_H__
+
+typedef struct {
+ unsigned long state[5];
+ unsigned long count[2];
+ unsigned char buffer[64];
+} SHA1_CTX;
+
+void SHA1Init(SHA1_CTX* context);
+void SHA1Update(SHA1_CTX* context, unsigned char* data, unsigned int len);
+void SHA1Final(unsigned char digest[20], SHA1_CTX* context);
+
+#endif/*__SHA1_H__*/
This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site.
|
