Use OpenSSL to implement SHA1 instead of our copy.

diff --git a/ios.sh b/ios.sh
index f4c112c6ef3dd81d846c5f93dfe2bfe698f0f70b..fb7c40949a963d348ea7a634d33328e5bf2d54f5 100755 (executable)
--- a/ios.sh
+++ b/ios.sh
@@ -1,2 +1,2 @@
 #!/bin/bash
 #!/bin/bash

-./make.sh true
+./make.sh true -Lsysroot/usr/lib

diff --git a/ldid.cpp b/ldid.cpp
index e1fbda9b5412e3b9d077bfb98f674e5f0cb9da5a..c2227a57de8f37ccbb5c4b0a9655cd3501255da7 100644 (file)
--- a/ldid.cpp
+++ b/ldid.cpp
@@ -23,14 +23,12 @@
 #include "minimal/string.h"
 #include "minimal/mapping.h"
 
 #include "minimal/string.h"
 #include "minimal/mapping.h"
 

-extern "C" {
-#include "sha1.h"
-}
-

 #include <cstring>
 #include <string>
 #include <vector>
 
 #include <cstring>
 #include <string>
 #include <vector>
 

+#include <openssl/sha.h>
+

 #include <plist/plist.h>
 
 struct fat_header {
 #include <plist/plist.h>
 
 struct fat_header {


@@ -719,10 +717,7 @@ struct CodeDirectory {
 extern "C" uint32_t hash(uint8_t *k, uint32_t length, uint32_t initval);
 
 void sha1(uint8_t *hash, uint8_t *data, size_t size) {
 extern "C" uint32_t hash(uint8_t *k, uint32_t length, uint32_t initval);
 
 void sha1(uint8_t *hash, uint8_t *data, size_t size) {

-    SHA1Context context;
-    SHA1Reset(&context);
-    SHA1Input(&context, data, size);
-    SHA1Result(&context, hash);
+    SHA1(data, size, hash);

 }
 
 struct CodesignAllocation {
 }
 
 struct CodesignAllocation {

diff --git a/make.sh b/make.sh
index da019ac9b3c53615408423c17974bc25913c3087..30fe7b06836067a5453c1c49b013c8e89470c013 100755 (executable)
--- a/make.sh
+++ b/make.sh
@@ -7,6 +7,7 @@ if [[ $# == 0 ]]; then
     ios=false
 else
     ios=$1
     ios=false
 else
     ios=$1

+    shift

 fi
 
 if "${ios}"; then
 fi
 
 if "${ios}"; then


@@ -40,6 +41,8 @@ flags+=(-I"${sdk}"/usr/include/libxml2)
 flags+=(-Ilibplist/include)
 flags+=(-Ilibplist/libcnary/include)
 
 flags+=(-Ilibplist/include)
 flags+=(-Ilibplist/libcnary/include)
 

+flags+=("$@")
+

 mkdir -p "${out}"
 os=()
 
 mkdir -p "${out}"
 os=()
 


@@ -55,7 +58,7 @@ done
 set -x
 
 "${flags[@]}" -c -std=c++11 -o "${out}"/ldid.o ldid.cpp
 set -x
 
 "${flags[@]}" -c -std=c++11 -o "${out}"/ldid.o ldid.cpp

-"${flags[@]}" -o "${out}"/ldid "${out}"/ldid.o "${os[@]}" -x c lookup2.c -x c sha1.c -lxml2
+"${flags[@]}" -o "${out}"/ldid "${out}"/ldid.o "${os[@]}" -x c lookup2.c -lxml2 -lcrypto

 
 if ! "${ios}"; then
     ln -sf out/ldid .
 
 if ! "${ios}"; then
     ln -sf out/ldid .

diff --git a/sha1.c b/sha1.c
deleted file mode 100644 (file)
index 2b74de8..0000000
--- a/sha1.c
+++ /dev/null
@@ -1,389 +0,0 @@
-/*\r
- *  sha1.c\r
- *\r
- *  Description:\r
- *      This file implements the Secure Hashing Algorithm 1 as\r
- *      defined in FIPS PUB 180-1 published April 17, 1995.\r
- *\r
- *      The SHA-1, produces a 160-bit message digest for a given\r
- *      data stream.  It should take about 2**n steps to find a\r
- *      message with the same digest as a given message and\r
- *      2**(n/2) to find any two messages with the same digest,\r
- *      when n is the digest size in bits.  Therefore, this\r
- *      algorithm can serve as a means of providing a\r
- *      "fingerprint" for a message.\r
- *\r
- *  Portability Issues:\r
- *      SHA-1 is defined in terms of 32-bit "words".  This code\r
- *      uses <stdint.h> (included via "sha1.h" to define 32 and 8\r
- *      bit unsigned integer types.  If your C compiler does not\r
- *      support 32 bit unsigned integers, this code is not\r
- *      appropriate.\r
- *\r
- *  Caveats:\r
- *      SHA-1 is designed to work with messages less than 2^64 bits\r
- *      long.  Although SHA-1 allows a message digest to be generated\r
- *      for messages of any number of bits less than 2^64, this\r
- *      implementation only works with messages with a length that is\r
- *      a multiple of the size of an 8-bit character.\r
- *\r
- */\r
-\r
-#include "sha1.h"\r
-\r
-/*\r
- *  Define the SHA1 circular left shift macro\r
- */\r
-#define SHA1CircularShift(bits,word) \\r
-                (((word) << (bits)) | ((word) >> (32-(bits))))\r
-\r
-/* Local Function Prototyptes */\r
-void SHA1PadMessage(SHA1Context *);\r
-void SHA1ProcessMessageBlock(SHA1Context *);\r
-\r
-/*\r
- *  SHA1Reset\r
- *\r
- *  Description:\r
- *      This function will initialize the SHA1Context in preparation\r
- *      for computing a new SHA1 message digest.\r
- *\r
- *  Parameters:\r
- *      context: [in/out]\r
- *          The context to reset.\r
- *\r
- *  Returns:\r
- *      sha Error Code.\r
- *\r
- */\r
-int SHA1Reset(SHA1Context *context)\r
-{\r
-    if (!context)\r
-    {\r
-        return shaNull;\r
-    }\r
-\r
-    context->Length_Low             = 0;\r
-    context->Length_High            = 0;\r
-    context->Message_Block_Index    = 0;\r
-\r
-    context->Intermediate_Hash[0]   = 0x67452301;\r
-    context->Intermediate_Hash[1]   = 0xEFCDAB89;\r
-    context->Intermediate_Hash[2]   = 0x98BADCFE;\r
-    context->Intermediate_Hash[3]   = 0x10325476;\r
-    context->Intermediate_Hash[4]   = 0xC3D2E1F0;\r
-\r
-    context->Computed   = 0;\r
-    context->Corrupted  = 0;\r
-\r
-    return shaSuccess;\r
-}\r
-\r
-/*\r
- *  SHA1Result\r
- *\r
- *  Description:\r
- *      This function will return the 160-bit message digest into the\r
- *      Message_Digest array  provided by the caller.\r
- *      NOTE: The first octet of hash is stored in the 0th element,\r
- *            the last octet of hash in the 19th element.\r
- *\r
- *  Parameters:\r
- *      context: [in/out]\r
- *          The context to use to calculate the SHA-1 hash.\r
- *      Message_Digest: [out]\r
- *          Where the digest is returned.\r
- *\r
- *  Returns:\r
- *      sha Error Code.\r
- *\r
- */\r
-int SHA1Result( SHA1Context *context,\r
-                uint8_t Message_Digest[SHA1HashSize])\r
-{\r
-    int i;\r
-\r
-    if (!context || !Message_Digest)\r
-    {\r
-        return shaNull;\r
-    }\r
-\r
-    if (context->Corrupted)\r
-    {\r
-        return context->Corrupted;\r
-    }\r
-\r
-    if (!context->Computed)\r
-    {\r
-        SHA1PadMessage(context);\r
-        for(i=0; i<64; ++i)\r
-        {\r
-            /* message may be sensitive, clear it out */\r
-            context->Message_Block[i] = 0;\r
-        }\r
-        context->Length_Low = 0;    /* and clear length */\r
-        context->Length_High = 0;\r
-        context->Computed = 1;\r
-\r
-    }\r
-\r
-    for(i = 0; i < SHA1HashSize; ++i)\r
-    {\r
-        Message_Digest[i] = context->Intermediate_Hash[i>>2]\r
-                            >> 8 * ( 3 - ( i & 0x03 ) );\r
-    }\r
-\r
-    return shaSuccess;\r
-}\r
-\r
-/*\r
- *  SHA1Input\r
- *\r
- *  Description:\r
- *      This function accepts an array of octets as the next portion\r
- *      of the message.\r
- *\r
- *  Parameters:\r
- *      context: [in/out]\r
- *          The SHA context to update\r
- *      message_array: [in]\r
- *          An array of characters representing the next portion of\r
- *          the message.\r
- *      length: [in]\r
- *          The length of the message in message_array\r
- *\r
- *  Returns:\r
- *      sha Error Code.\r
- *\r
- */\r
-int SHA1Input(    SHA1Context    *context,\r
-                  const uint8_t  *message_array,\r
-                  unsigned       length)\r
-{\r
-    if (!length)\r
-    {\r
-        return shaSuccess;\r
-    }\r
-\r
-    if (!context || !message_array)\r
-    {\r
-        return shaNull;\r
-    }\r
-\r
-    if (context->Computed)\r
-    {\r
-        context->Corrupted = shaStateError;\r
-\r
-        return shaStateError;\r
-    }\r
-\r
-    if (context->Corrupted)\r
-    {\r
-         return context->Corrupted;\r
-    }\r
-    while(length-- && !context->Corrupted)\r
-    {\r
-    context->Message_Block[context->Message_Block_Index++] =\r
-                    (*message_array & 0xFF);\r
-\r
-    context->Length_Low += 8;\r
-    if (context->Length_Low == 0)\r
-    {\r
-        context->Length_High++;\r
-        if (context->Length_High == 0)\r
-        {\r
-            /* Message is too long */\r
-            context->Corrupted = 1;\r
-        }\r
-    }\r
-\r
-    if (context->Message_Block_Index == 64)\r
-    {\r
-        SHA1ProcessMessageBlock(context);\r
-    }\r
-\r
-    message_array++;\r
-    }\r
-\r
-    return shaSuccess;\r
-}\r
-\r
-/*\r
- *  SHA1ProcessMessageBlock\r
- *\r
- *  Description:\r
- *      This function will process the next 512 bits of the message\r
- *      stored in the Message_Block array.\r
- *\r
- *  Parameters:\r
- *      None.\r
- *\r
- *  Returns:\r
- *      Nothing.\r
- *\r
- *  Comments:\r
-\r
- *      Many of the variable names in this code, especially the\r
- *      single character names, were used because those were the\r
- *      names used in the publication.\r
- *\r
- *\r
- */\r
-void SHA1ProcessMessageBlock(SHA1Context *context)\r
-{\r
-    const uint32_t K[] =    {       /* Constants defined in SHA-1   */\r
-                            0x5A827999,\r
-                            0x6ED9EBA1,\r
-                            0x8F1BBCDC,\r
-                            0xCA62C1D6\r
-                            };\r
-    int           t;                 /* Loop counter                */\r
-    uint32_t      temp;              /* Temporary word value        */\r
-    uint32_t      W[80];             /* Word sequence               */\r
-    uint32_t      A, B, C, D, E;     /* Word buffers                */\r
-\r
-    /*\r
-     *  Initialize the first 16 words in the array W\r
-     */\r
-    for(t = 0; t < 16; t++)\r
-    {\r
-        W[t] = context->Message_Block[t * 4] << 24;\r
-        W[t] |= context->Message_Block[t * 4 + 1] << 16;\r
-        W[t] |= context->Message_Block[t * 4 + 2] << 8;\r
-        W[t] |= context->Message_Block[t * 4 + 3];\r
-    }\r
-\r
-    for(t = 16; t < 80; t++)\r
-    {\r
-       W[t] = SHA1CircularShift(1,W[t-3] ^ W[t-8] ^ W[t-14] ^ W[t-16]);\r
-    }\r
-\r
-    A = context->Intermediate_Hash[0];\r
-    B = context->Intermediate_Hash[1];\r
-    C = context->Intermediate_Hash[2];\r
-    D = context->Intermediate_Hash[3];\r
-    E = context->Intermediate_Hash[4];\r
-\r
-    for(t = 0; t < 20; t++)\r
-    {\r
-        temp =  SHA1CircularShift(5,A) +\r
-                ((B & C) | ((~B) & D)) + E + W[t] + K[0];\r
-        E = D;\r
-        D = C;\r
-        C = SHA1CircularShift(30,B);\r
-\r
-        B = A;\r
-        A = temp;\r
-    }\r
-\r
-    for(t = 20; t < 40; t++)\r
-    {\r
-        temp = SHA1CircularShift(5,A) + (B ^ C ^ D) + E + W[t] + K[1];\r
-        E = D;\r
-        D = C;\r
-        C = SHA1CircularShift(30,B);\r
-        B = A;\r
-        A = temp;\r
-    }\r
-\r
-    for(t = 40; t < 60; t++)\r
-    {\r
-        temp = SHA1CircularShift(5,A) +\r
-               ((B & C) | (B & D) | (C & D)) + E + W[t] + K[2];\r
-        E = D;\r
-        D = C;\r
-        C = SHA1CircularShift(30,B);\r
-        B = A;\r
-        A = temp;\r
-    }\r
-\r
-    for(t = 60; t < 80; t++)\r
-    {\r
-        temp = SHA1CircularShift(5,A) + (B ^ C ^ D) + E + W[t] + K[3];\r
-        E = D;\r
-        D = C;\r
-        C = SHA1CircularShift(30,B);\r
-        B = A;\r
-        A = temp;\r
-    }\r
-\r
-    context->Intermediate_Hash[0] += A;\r
-    context->Intermediate_Hash[1] += B;\r
-    context->Intermediate_Hash[2] += C;\r
-    context->Intermediate_Hash[3] += D;\r
-    context->Intermediate_Hash[4] += E;\r
-\r
-    context->Message_Block_Index = 0;\r
-}\r
-\r
-/*\r
- *  SHA1PadMessage\r
- *\r
-\r
- *  Description:\r
- *      According to the standard, the message must be padded to an even\r
- *      512 bits.  The first padding bit must be a '1'.  The last 64\r
- *      bits represent the length of the original message.  All bits in\r
- *      between should be 0.  This function will pad the message\r
- *      according to those rules by filling the Message_Block array\r
- *      accordingly.  It will also call the ProcessMessageBlock function\r
- *      provided appropriately.  When it returns, it can be assumed that\r
- *      the message digest has been computed.\r
- *\r
- *  Parameters:\r
- *      context: [in/out]\r
- *          The context to pad\r
- *      ProcessMessageBlock: [in]\r
- *          The appropriate SHA*ProcessMessageBlock function\r
- *  Returns:\r
- *      Nothing.\r
- *\r
- */\r
-\r
-void SHA1PadMessage(SHA1Context *context)\r
-{\r
-    /*\r
-     *  Check to see if the current message block is too small to hold\r
-     *  the initial padding bits and length.  If so, we will pad the\r
-     *  block, process it, and then continue padding into a second\r
-     *  block.\r
-     */\r
-    if (context->Message_Block_Index > 55)\r
-    {\r
-        context->Message_Block[context->Message_Block_Index++] = 0x80;\r
-        while(context->Message_Block_Index < 64)\r
-        {\r
-            context->Message_Block[context->Message_Block_Index++] = 0;\r
-        }\r
-\r
-        SHA1ProcessMessageBlock(context);\r
-\r
-        while(context->Message_Block_Index < 56)\r
-        {\r
-            context->Message_Block[context->Message_Block_Index++] = 0;\r
-        }\r
-    }\r
-    else\r
-    {\r
-        context->Message_Block[context->Message_Block_Index++] = 0x80;\r
-        while(context->Message_Block_Index < 56)\r
-        {\r
-\r
-            context->Message_Block[context->Message_Block_Index++] = 0;\r
-        }\r
-    }\r
-\r
-    /*\r
-     *  Store the message length as the last 8 octets\r
-     */\r
-    context->Message_Block[56] = context->Length_High >> 24;\r
-    context->Message_Block[57] = context->Length_High >> 16;\r
-    context->Message_Block[58] = context->Length_High >> 8;\r
-    context->Message_Block[59] = context->Length_High;\r
-    context->Message_Block[60] = context->Length_Low >> 24;\r
-    context->Message_Block[61] = context->Length_Low >> 16;\r
-    context->Message_Block[62] = context->Length_Low >> 8;\r
-    context->Message_Block[63] = context->Length_Low;\r
-\r
-    SHA1ProcessMessageBlock(context);\r
-}\r