granicus.if.org Git - imagemagick/blob - MagickCore/signature.c

   1 /*
   2 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
   3 %                                                                             %
   4 %                                                                             %
   5 %        SSSSS  IIIII   GGGG  N   N   AAA   TTTTT  U   U  RRRR   EEEEE        %
   6 %        SS       I    G      NN  N  A   A    T    U   U  R   R  E            %
   7 %         SSS     I    G  GG  N N N  AAAAA    T    U   U  RRRR   EEE          %
   8 %           SS    I    G   G  N  NN  A   A    T    U   U  R R    E            %
   9 %        SSSSS  IIIII   GGG   N   N  A   A    T     UUU   R  R   EEEEE        %
  10 %                                                                             %
  11 %                                                                             %
  12 %         MagickCore Methods to Compute a Message Digest for an Image         %
  13 %                                                                             %
  14 %                             Software Design                                 %
  15 %                               John Cristy                                   %
  16 %                              December 1992                                  %
  17 %                                                                             %
  18 %                                                                             %
  19 %  Copyright 1999-2011 ImageMagick Studio LLC, a non-profit organization      %
  20 %  dedicated to making software imaging solutions freely available.           %
  21 %                                                                             %
  22 %  You may not use this file except in compliance with the License.  You may  %
  23 %  obtain a copy of the License at                                            %
  24 %                                                                             %
  25 %    http://www.imagemagick.org/script/license.php                            %
  26 %                                                                             %
  27 %  Unless required by applicable law or agreed to in writing, software        %
  28 %  distributed under the License is distributed on an "AS IS" BASIS,          %
  29 %  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.   %
  30 %  See the License for the specific language governing permissions and        %
  31 %  limitations under the License.                                             %
  32 %                                                                             %
  33 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
  34 %
  35 %
  36 %
  37 */
  38 \f
  39 /*
  40   Include declarations.
  41 */
  42 #include "MagickCore/studio.h"
  43 #include "MagickCore/cache.h"
  44 #include "MagickCore/exception.h"
  45 #include "MagickCore/exception-private.h"
  46 #include "MagickCore/property.h"
  47 #include "MagickCore/image.h"
  48 #include "MagickCore/memory_.h"
  49 #include "MagickCore/quantum.h"
  50 #include "MagickCore/quantum-private.h"
  51 #include "MagickCore/signature.h"
  52 #include "MagickCore/signature-private.h"
  53 #include "MagickCore/string_.h"
  54 /*
  55   Define declarations.
  56 */
  57 #define SignatureBlocksize  64
  58 #define SignatureDigestsize  32
  59 \f
  60 /*
  61   Typedef declarations.
  62 */
  63 struct _SignatureInfo
  64 {
  65   unsigned int
  66     digestsize,
  67     blocksize;
  68
  69   StringInfo
  70     *digest,
  71     *message;
  72
  73   unsigned int
  74     *accumulator,
  75     low_order,
  76     high_order;
  77
  78   size_t
  79     offset;
  80
  81   MagickBooleanType
  82     lsb_first;
  83
  84   ssize_t
  85     timestamp;
  86
  87   size_t
  88     signature;
  89 };
  90 \f
  91 /*
  92   Forward declarations.
  93 */
  94 static void
  95   TransformSignature(SignatureInfo *);
  96 \f
  97 /*
  98 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
  99 %                                                                             %
 100 %                                                                             %
 101 %                                                                             %
 102 +   A c q u i r e S i g n a t u r e I n f o                                   %
 103 %                                                                             %
 104 %                                                                             %
 105 %                                                                             %
 106 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 107 %
 108 %  AcquireSignatureInfo() allocate the SignatureInfo structure.
 109 %
 110 %  The format of the AcquireSignatureInfo method is:
 111 %
 112 %      SignatureInfo *AcquireSignatureInfo(void)
 113 %
 114 */
 115 MagickPrivate SignatureInfo *AcquireSignatureInfo(void)
 116 {
 117   SignatureInfo
 118     *signature_info;
 119
 120   unsigned int
 121     lsb_first;
 122
 123   signature_info=(SignatureInfo *) AcquireMagickMemory(sizeof(*signature_info));
 124   if (signature_info == (SignatureInfo *) NULL)
 125     ThrowFatalException(ResourceLimitFatalError,"MemoryAllocationFailed");
 126   (void) ResetMagickMemory(signature_info,0,sizeof(*signature_info));
 127   signature_info->digestsize=SignatureDigestsize;
 128   signature_info->blocksize=SignatureBlocksize;
 129   signature_info->digest=AcquireStringInfo(SignatureDigestsize);
 130   signature_info->message=AcquireStringInfo(SignatureBlocksize);
 131   signature_info->accumulator=(unsigned int *) AcquireQuantumMemory(
 132     SignatureBlocksize,sizeof(*signature_info->accumulator));
 133   if (signature_info->accumulator == (unsigned int *) NULL)
 134     ThrowFatalException(ResourceLimitFatalError,"MemoryAllocationFailed");
 135   lsb_first=1;
 136   signature_info->lsb_first=(int) (*(char *) &lsb_first) == 1 ? MagickTrue :
 137     MagickFalse;
 138   signature_info->timestamp=(ssize_t) time(0);
 139   signature_info->signature=MagickSignature;
 140   InitializeSignature(signature_info);
 141   return(signature_info);
 142 }
 143 \f
 144 /*
 145 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 146 %                                                                             %
 147 %                                                                             %
 148 %                                                                             %
 149 +   D e s t r o y S i g n a t u r e I n f o                                   %
 150 %                                                                             %
 151 %                                                                             %
 152 %                                                                             %
 153 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 154 %
 155 %  DestroySignatureInfo() zeros memory associated with the SignatureInfo
 156 %  structure.
 157 %
 158 %  The format of the DestroySignatureInfo method is:
 159 %
 160 %      SignatureInfo *DestroySignatureInfo(SignatureInfo *signature_info)
 161 %
 162 %  A description of each parameter follows:
 163 %
 164 %    o signature_info: the cipher signature_info.
 165 %
 166 */
 167 MagickPrivate SignatureInfo *DestroySignatureInfo(SignatureInfo *signature_info)
 168 {
 169   (void) LogMagickEvent(TraceEvent,GetMagickModule(),"...");
 170   assert(signature_info != (SignatureInfo *) NULL);
 171   assert(signature_info->signature == MagickSignature);
 172   if (signature_info->accumulator != (unsigned int *) NULL)
 173     signature_info->accumulator=(unsigned int *) RelinquishMagickMemory(
 174       signature_info->accumulator);
 175   if (signature_info->message != (StringInfo *) NULL)
 176     signature_info->message=DestroyStringInfo(signature_info->message);
 177   if (signature_info->digest != (StringInfo *) NULL)
 178     signature_info->digest=DestroyStringInfo(signature_info->digest);
 179   signature_info->signature=(~MagickSignature);
 180   signature_info=(SignatureInfo *) RelinquishMagickMemory(signature_info);
 181   return(signature_info);
 182 }
 183 \f
 184 /*
 185 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 186 %                                                                             %
 187 %                                                                             %
 188 %                                                                             %
 189 +   F i n a l i z e S i g n a t u r e                                         %
 190 %                                                                             %
 191 %                                                                             %
 192 %                                                                             %
 193 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 194 %
 195 %  FinalizeSignature() finalizes the Signature message accumulator computation.
 196 %
 197 %  The format of the FinalizeSignature method is:
 198 %
 199 %      FinalizeSignature(SignatureInfo *signature_info)
 200 %
 201 %  A description of each parameter follows:
 202 %
 203 %    o signature_info: the address of a structure of type SignatureInfo.
 204 %
 205 */
 206 MagickPrivate void FinalizeSignature(SignatureInfo *signature_info)
 207 {
 208   register ssize_t
 209     i;
 210
 211   register unsigned char
 212     *q;
 213
 214   register unsigned int
 215     *p;
 216
 217   unsigned char
 218     *datum;
 219
 220   unsigned int
 221     count,
 222     high_order,
 223     low_order;
 224
 225   /*
 226     Add padding and return the message accumulator.
 227   */
 228   (void) LogMagickEvent(TraceEvent,GetMagickModule(),"...");
 229   assert(signature_info != (SignatureInfo *) NULL);
 230   assert(signature_info->signature == MagickSignature);
 231   low_order=signature_info->low_order;
 232   high_order=signature_info->high_order;
 233   count=((low_order >> 3) & 0x3f);
 234   datum=GetStringInfoDatum(signature_info->message);
 235   datum[count++]=(unsigned char) 0x80;
 236   if (count <= (unsigned int) (GetStringInfoLength(signature_info->message)-8))
 237     (void) ResetMagickMemory(datum+count,0,GetStringInfoLength(
 238       signature_info->message)-8-count);
 239   else
 240     {
 241       (void) ResetMagickMemory(datum+count,0,GetStringInfoLength(
 242         signature_info->message)-count);
 243       TransformSignature(signature_info);
 244       (void) ResetMagickMemory(datum,0,GetStringInfoLength(
 245         signature_info->message)-8);
 246     }
 247   datum[56]=(unsigned char) (high_order >> 24);
 248   datum[57]=(unsigned char) (high_order >> 16);
 249   datum[58]=(unsigned char) (high_order >> 8);
 250   datum[59]=(unsigned char) high_order;
 251   datum[60]=(unsigned char) (low_order >> 24);
 252   datum[61]=(unsigned char) (low_order >> 16);
 253   datum[62]=(unsigned char) (low_order >> 8);
 254   datum[63]=(unsigned char) low_order;
 255   TransformSignature(signature_info);
 256   p=signature_info->accumulator;
 257   q=GetStringInfoDatum(signature_info->digest);
 258   for (i=0; i < (SignatureDigestsize/4); i++)
 259   {
 260     *q++=(unsigned char) ((*p >> 24) & 0xff);
 261     *q++=(unsigned char) ((*p >> 16) & 0xff);
 262     *q++=(unsigned char) ((*p >> 8) & 0xff);
 263     *q++=(unsigned char) (*p & 0xff);
 264     p++;
 265   }
 266   /*
 267     Reset working registers.
 268   */
 269   count=0;
 270   high_order=0;
 271   low_order=0;
 272 }
 273 \f
 274 /*
 275 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 276 %                                                                             %
 277 %                                                                             %
 278 %                                                                             %
 279 +   G e t S i g n a t u r e B l o c k s i z e                                 %
 280 %                                                                             %
 281 %                                                                             %
 282 %                                                                             %
 283 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 284 %
 285 %  GetSignatureBlocksize() returns the Signature blocksize.
 286 %
 287 %  The format of the GetSignatureBlocksize method is:
 288 %
 289 %      unsigned int *GetSignatureBlocksize(const SignatureInfo *signature_info)
 290 %
 291 %  A description of each parameter follows:
 292 %
 293 %    o signature_info: the signature info.
 294 %
 295 */
 296 MagickPrivate unsigned int GetSignatureBlocksize(
 297   const SignatureInfo *signature_info)
 298 {
 299   (void) LogMagickEvent(TraceEvent,GetMagickModule(),"...");
 300   assert(signature_info != (SignatureInfo *) NULL);
 301   assert(signature_info->signature == MagickSignature);
 302   return(signature_info->blocksize);
 303 }
 304 \f
 305 /*
 306 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 307 %                                                                             %
 308 %                                                                             %
 309 %                                                                             %
 310 +   G e t S i g n a t u r e D i g e s t                                       %
 311 %                                                                             %
 312 %                                                                             %
 313 %                                                                             %
 314 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 315 %
 316 %  GetSignatureDigest() returns the signature digest.
 317 %
 318 %  The format of the GetSignatureDigest method is:
 319 %
 320 %      const StringInfo *GetSignatureDigest(const SignatureInfo *signature_info)
 321 %
 322 %  A description of each parameter follows:
 323 %
 324 %    o signature_info: the signature info.
 325 %
 326 */
 327 MagickPrivate const StringInfo *GetSignatureDigest(
 328   const SignatureInfo *signature_info)
 329 {
 330   (void) LogMagickEvent(TraceEvent,GetMagickModule(),"...");
 331   assert(signature_info != (SignatureInfo *) NULL);
 332   assert(signature_info->signature == MagickSignature);
 333   return(signature_info->digest);
 334 }
 335 \f
 336 /*
 337 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 338 %                                                                             %
 339 %                                                                             %
 340 %                                                                             %
 341 +   G e t S i g n a t u r e D i g e s t s i z e                               %
 342 %                                                                             %
 343 %                                                                             %
 344 %                                                                             %
 345 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 346 %
 347 %  GetSignatureDigestsize() returns the Signature digest size.
 348 %
 349 %  The format of the GetSignatureDigestsize method is:
 350 %
 351 %      unsigned int *GetSignatureDigestsize(const SignatureInfo *signature_info)
 352 %
 353 %  A description of each parameter follows:
 354 %
 355 %    o signature_info: the signature info.
 356 %
 357 */
 358 MagickPrivate unsigned int GetSignatureDigestsize(
 359   const SignatureInfo *signature_info)
 360 {
 361   (void) LogMagickEvent(TraceEvent,GetMagickModule(),"...");
 362   assert(signature_info != (SignatureInfo *) NULL);
 363   assert(signature_info->signature == MagickSignature);
 364   return(signature_info->digestsize);
 365 }
 366 \f
 367 /*
 368 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 369 %                                                                             %
 370 %                                                                             %
 371 %                                                                             %
 372 +   I n i t i a l i z e S i g n a t u r e                                     %
 373 %                                                                             %
 374 %                                                                             %
 375 %                                                                             %
 376 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 377 %
 378 %  InitializeSignature() initializes the Signature accumulator.
 379 %
 380 %  The format of the DestroySignatureInfo method is:
 381 %
 382 %      void InitializeSignatureInfo(SignatureInfo *signature_info)
 383 %
 384 %  A description of each parameter follows:
 385 %
 386 %    o signature_info: the cipher signature_info.
 387 %
 388 */
 389 MagickPrivate void InitializeSignature(SignatureInfo *signature_info)
 390 {
 391   (void) LogMagickEvent(TraceEvent,GetMagickModule(),"...");
 392   assert(signature_info != (SignatureInfo *) NULL);
 393   assert(signature_info->signature == MagickSignature);
 394   signature_info->accumulator[0]=0x6a09e667U;
 395   signature_info->accumulator[1]=0xbb67ae85U;
 396   signature_info->accumulator[2]=0x3c6ef372U;
 397   signature_info->accumulator[3]=0xa54ff53aU;
 398   signature_info->accumulator[4]=0x510e527fU;
 399   signature_info->accumulator[5]=0x9b05688cU;
 400   signature_info->accumulator[6]=0x1f83d9abU;
 401   signature_info->accumulator[7]=0x5be0cd19U;
 402   signature_info->low_order=0;
 403   signature_info->high_order=0;
 404   signature_info->offset=0;
 405 }
 406 \f
 407 /*
 408 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 409 %                                                                             %
 410 %                                                                             %
 411 %                                                                             %
 412 +   S e t S i g n a t u r e D i g e s t                                       %
 413 %                                                                             %
 414 %                                                                             %
 415 %                                                                             %
 416 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 417 %
 418 %  SetSignatureDigest() set the signature digest.
 419 %
 420 %  The format of the SetSignatureDigest method is:
 421 %
 422 %      SetSignatureDigest(SignatureInfo *signature_info,
 423 %        const StringInfo *digest)
 424 %
 425 %  A description of each parameter follows:
 426 %
 427 %    o signature_info: the signature info.
 428 %
 429 %    o digest: the digest.
 430 %
 431 */
 432 MagickPrivate void SetSignatureDigest(SignatureInfo *signature_info,
 433   const StringInfo *digest)
 434 {
 435   /*
 436     Set the signature accumulator.
 437   */
 438   assert(signature_info != (SignatureInfo *) NULL);
 439   assert(signature_info->signature == MagickSignature);
 440   SetStringInfo(signature_info->digest,digest);
 441 }
 442 \f
 443 /*
 444 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 445 %                                                                             %
 446 %                                                                             %
 447 %                                                                             %
 448 %   S i g n a t u r e I m a g e                                               %
 449 %                                                                             %
 450 %                                                                             %
 451 %                                                                             %
 452 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 453 %
 454 %  SignatureImage() computes a message digest from an image pixel stream with
 455 %  an implementation of the NIST SHA-256 Message Digest algorithm.  This
 456 %  signature uniquely identifies the image and is convenient for determining
 457 %  if an image has been modified or whether two images are identical.
 458 %
 459 %  The format of the SignatureImage method is:
 460 %
 461 %      MagickBooleanType SignatureImage(Image *image,ExceptionInfo *exception)
 462 %
 463 %  A description of each parameter follows:
 464 %
 465 %    o image: the image.
 466 %
 467 %    o exception: return any errors or warnings in this structure.
 468 %
 469 */
 470 MagickExport MagickBooleanType SignatureImage(Image *image,
 471   ExceptionInfo *exception)
 472 {
 473   CacheView
 474     *image_view;
 475
 476   char
 477     *hex_signature;
 478
 479   QuantumInfo
 480     *quantum_info;
 481
 482   QuantumType
 483     quantum_type;
 484
 485   register const Quantum
 486     *p;
 487
 488   SignatureInfo
 489     *signature_info;
 490
 491   size_t
 492     length;
 493
 494   ssize_t
 495     y;
 496
 497   StringInfo
 498     *signature;
 499
 500   unsigned char
 501     *pixels;
 502
 503   /*
 504     Compute image digital signature.
 505   */
 506   assert(image != (Image *) NULL);
 507   assert(image->signature == MagickSignature);
 508   if (image->debug != MagickFalse)
 509     (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
 510   quantum_info=AcquireQuantumInfo((const ImageInfo *) NULL,image);
 511   if (quantum_info == (QuantumInfo *) NULL)
 512     ThrowBinaryException(ResourceLimitError,"MemoryAllocationFailed",
 513       image->filename);
 514   quantum_type=RGBQuantum;
 515   if (image->matte != MagickFalse)
 516     quantum_type=RGBAQuantum;
 517   if (image->colorspace == CMYKColorspace)
 518     {
 519       quantum_type=CMYKQuantum;
 520       if (image->matte != MagickFalse)
 521         quantum_type=CMYKAQuantum;
 522     }
 523   signature_info=AcquireSignatureInfo();
 524   signature=AcquireStringInfo(quantum_info->extent);
 525   pixels=GetQuantumPixels(quantum_info);
 526   image_view=AcquireCacheView(image);
 527   for (y=0; y < (ssize_t) image->rows; y++)
 528   {
 529     p=GetCacheViewVirtualPixels(image_view,0,y,image->columns,1,exception);
 530     if (p == (const Quantum *) NULL)
 531       break;
 532     length=ExportQuantumPixels(image,image_view,quantum_info,quantum_type,
 533       pixels,&image->exception);
 534     SetStringInfoLength(signature,length);
 535     SetStringInfoDatum(signature,pixels);
 536     UpdateSignature(signature_info,signature);
 537   }
 538   image_view=DestroyCacheView(image_view);
 539   quantum_info=DestroyQuantumInfo(quantum_info);
 540   FinalizeSignature(signature_info);
 541   hex_signature=StringInfoToHexString(GetSignatureDigest(signature_info));
 542   (void) DeleteImageProperty(image,"signature");
 543   (void) SetImageProperty(image,"signature",hex_signature);
 544   /*
 545     Free resources.
 546   */
 547   hex_signature=DestroyString(hex_signature);
 548   signature=DestroyStringInfo(signature);
 549   signature_info=DestroySignatureInfo(signature_info);
 550   return(MagickTrue);
 551 }
 552 \f
 553 /*
 554 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 555 %                                                                             %
 556 %                                                                             %
 557 %                                                                             %
 558 +   T r a n s f o r m S i g n a t u r e                                       %
 559 %                                                                             %
 560 %                                                                             %
 561 %                                                                             %
 562 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 563 %
 564 %  TransformSignature() transforms the Signature message accumulator.
 565 %
 566 %  The format of the TransformSignature method is:
 567 %
 568 %      TransformSignature(SignatureInfo *signature_info)
 569 %
 570 %  A description of each parameter follows:
 571 %
 572 %    o signature_info: the address of a structure of type SignatureInfo.
 573 %
 574 */
 575
 576 static inline unsigned int Ch(unsigned int x,unsigned int y,unsigned int z)
 577 {
 578   return((x & y) ^ (~x & z));
 579 }
 580
 581 static inline unsigned int Maj(unsigned int x,unsigned int y,unsigned int z)
 582 {
 583   return((x & y) ^ (x & z) ^ (y & z));
 584 }
 585
 586 static inline unsigned int Trunc32(unsigned int x)
 587 {
 588   return((unsigned int) (x & 0xffffffffU));
 589 }
 590
 591 static unsigned int RotateRight(unsigned int x,unsigned int n)
 592 {
 593   return(Trunc32((x >> n) | (x << (32-n))));
 594 }
 595
 596 static void TransformSignature(SignatureInfo *signature_info)
 597 {
 598 #define Sigma0(x)  (RotateRight(x,7) ^ RotateRight(x,18) ^ Trunc32((x) >> 3))
 599 #define Sigma1(x)  (RotateRight(x,17) ^ RotateRight(x,19) ^ Trunc32((x) >> 10))
 600 #define Suma0(x)  (RotateRight(x,2) ^ RotateRight(x,13) ^ RotateRight(x,22))
 601 #define Suma1(x)  (RotateRight(x,6) ^ RotateRight(x,11) ^ RotateRight(x,25))
 602
 603   register ssize_t
 604     i;
 605
 606   register unsigned char
 607     *p;
 608
 609   ssize_t
 610     j;
 611
 612   static unsigned int
 613     K[64] =
 614     {
 615       0x428a2f98U, 0x71374491U, 0xb5c0fbcfU, 0xe9b5dba5U, 0x3956c25bU,
 616       0x59f111f1U, 0x923f82a4U, 0xab1c5ed5U, 0xd807aa98U, 0x12835b01U,
 617       0x243185beU, 0x550c7dc3U, 0x72be5d74U, 0x80deb1feU, 0x9bdc06a7U,
 618       0xc19bf174U, 0xe49b69c1U, 0xefbe4786U, 0x0fc19dc6U, 0x240ca1ccU,
 619       0x2de92c6fU, 0x4a7484aaU, 0x5cb0a9dcU, 0x76f988daU, 0x983e5152U,
 620       0xa831c66dU, 0xb00327c8U, 0xbf597fc7U, 0xc6e00bf3U, 0xd5a79147U,
 621       0x06ca6351U, 0x14292967U, 0x27b70a85U, 0x2e1b2138U, 0x4d2c6dfcU,
 622       0x53380d13U, 0x650a7354U, 0x766a0abbU, 0x81c2c92eU, 0x92722c85U,
 623       0xa2bfe8a1U, 0xa81a664bU, 0xc24b8b70U, 0xc76c51a3U, 0xd192e819U,
 624       0xd6990624U, 0xf40e3585U, 0x106aa070U, 0x19a4c116U, 0x1e376c08U,
 625       0x2748774cU, 0x34b0bcb5U, 0x391c0cb3U, 0x4ed8aa4aU, 0x5b9cca4fU,
 626       0x682e6ff3U, 0x748f82eeU, 0x78a5636fU, 0x84c87814U, 0x8cc70208U,
 627       0x90befffaU, 0xa4506cebU, 0xbef9a3f7U, 0xc67178f2U
 628     };  /* 32-bit fractional part of the cube root of the first 64 primes */
 629
 630   unsigned int
 631     A,
 632     B,
 633     C,
 634     D,
 635     E,
 636     F,
 637     G,
 638     H,
 639     shift,
 640     T,
 641     T1,
 642     T2,
 643     W[64];
 644
 645   shift=32;
 646   p=GetStringInfoDatum(signature_info->message);
 647   if (signature_info->lsb_first == MagickFalse)
 648     {
 649       if (sizeof(unsigned int) <= 4)
 650         for (i=0; i < 16; i++)
 651         {
 652           T=(*((unsigned int *) p));
 653           p+=4;
 654           W[i]=Trunc32(T);
 655         }
 656       else
 657         for (i=0; i < 16; i+=2)
 658         {
 659           T=(*((unsigned int *) p));
 660           p+=8;
 661           W[i]=Trunc32(T >> shift);
 662           W[i+1]=Trunc32(T);
 663         }
 664     }
 665   else
 666     if (sizeof(unsigned int) <= 4)
 667       for (i=0; i < 16; i++)
 668       {
 669         T=(*((unsigned int *) p));
 670         p+=4;
 671         W[i]=((T << 24) & 0xff000000) | ((T << 8) & 0x00ff0000) |
 672           ((T >> 8) & 0x0000ff00) | ((T >> 24) & 0x000000ff);
 673       }
 674     else
 675       for (i=0; i < 16; i+=2)
 676       {
 677         T=(*((unsigned int *) p));
 678         p+=8;
 679         W[i]=((T << 24) & 0xff000000) | ((T << 8) & 0x00ff0000) |
 680           ((T >> 8) & 0x0000ff00) | ((T >> 24) & 0x000000ff);
 681         T>>=shift;
 682         W[i+1]=((T << 24) & 0xff000000) | ((T << 8) & 0x00ff0000) |
 683           ((T >> 8) & 0x0000ff00) | ((T >> 24) & 0x000000ff);
 684       }
 685   /*
 686     Copy accumulator to registers.
 687   */
 688   A=signature_info->accumulator[0];
 689   B=signature_info->accumulator[1];
 690   C=signature_info->accumulator[2];
 691   D=signature_info->accumulator[3];
 692   E=signature_info->accumulator[4];
 693   F=signature_info->accumulator[5];
 694   G=signature_info->accumulator[6];
 695   H=signature_info->accumulator[7];
 696   for (i=16; i < 64; i++)
 697     W[i]=Trunc32(Sigma1(W[i-2])+W[i-7]+Sigma0(W[i-15])+W[i-16]);
 698   for (j=0; j < 64; j++)
 699   {
 700     T1=Trunc32(H+Suma1(E)+Ch(E,F,G)+K[j]+W[j]);
 701     T2=Trunc32(Suma0(A)+Maj(A,B,C));
 702     H=G;
 703     G=F;
 704     F=E;
 705     E=Trunc32(D+T1);
 706     D=C;
 707     C=B;
 708     B=A;
 709     A=Trunc32(T1+T2);
 710   }
 711   /*
 712     Add registers back to accumulator.
 713   */
 714   signature_info->accumulator[0]=Trunc32(signature_info->accumulator[0]+A);
 715   signature_info->accumulator[1]=Trunc32(signature_info->accumulator[1]+B);
 716   signature_info->accumulator[2]=Trunc32(signature_info->accumulator[2]+C);
 717   signature_info->accumulator[3]=Trunc32(signature_info->accumulator[3]+D);
 718   signature_info->accumulator[4]=Trunc32(signature_info->accumulator[4]+E);
 719   signature_info->accumulator[5]=Trunc32(signature_info->accumulator[5]+F);
 720   signature_info->accumulator[6]=Trunc32(signature_info->accumulator[6]+G);
 721   signature_info->accumulator[7]=Trunc32(signature_info->accumulator[7]+H);
 722   /*
 723     Reset working registers.
 724   */
 725   A=0;
 726   B=0;
 727   C=0;
 728   D=0;
 729   E=0;
 730   F=0;
 731   G=0;
 732   H=0;
 733   T=0;
 734   T1=0;
 735   T2=0;
 736   (void) ResetMagickMemory(W,0,sizeof(W));
 737 }
 738 \f
 739 /*
 740 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 741 %                                                                             %
 742 %                                                                             %
 743 %                                                                             %
 744 +   U p d a t e S i g n a t u r e                                             %
 745 %                                                                             %
 746 %                                                                             %
 747 %                                                                             %
 748 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 749 %
 750 %  UpdateSignature() updates the Signature message accumulator.
 751 %
 752 %  The format of the UpdateSignature method is:
 753 %
 754 %      UpdateSignature(SignatureInfo *signature_info,const StringInfo *message)
 755 %
 756 %  A description of each parameter follows:
 757 %
 758 %    o signature_info: the address of a structure of type SignatureInfo.
 759 %
 760 %    o message: the message.
 761 %
 762 */
 763 MagickPrivate void UpdateSignature(SignatureInfo *signature_info,
 764   const StringInfo *message)
 765 {
 766   register size_t
 767     i;
 768
 769   register unsigned char
 770     *p;
 771
 772   size_t
 773     n;
 774
 775   unsigned int
 776     length;
 777
 778   /*
 779     Update the Signature accumulator.
 780   */
 781   assert(signature_info != (SignatureInfo *) NULL);
 782   assert(signature_info->signature == MagickSignature);
 783   n=GetStringInfoLength(message);
 784   length=Trunc32((unsigned int) (signature_info->low_order+(n << 3)));
 785   if (length < signature_info->low_order)
 786     signature_info->high_order++;
 787   signature_info->low_order=length;
 788   signature_info->high_order+=(unsigned int) (n >> 29);
 789   p=GetStringInfoDatum(message);
 790   if (signature_info->offset != 0)
 791     {
 792       i=GetStringInfoLength(signature_info->message)-signature_info->offset;
 793       if (i > n)
 794         i=n;
 795       (void) CopyMagickMemory(GetStringInfoDatum(signature_info->message)+
 796         signature_info->offset,p,i);
 797       n-=i;
 798       p+=i;
 799       signature_info->offset+=i;
 800       if (signature_info->offset !=
 801           GetStringInfoLength(signature_info->message))
 802         return;
 803       TransformSignature(signature_info);
 804     }
 805   while (n >= GetStringInfoLength(signature_info->message))
 806   {
 807     SetStringInfoDatum(signature_info->message,p);
 808     p+=GetStringInfoLength(signature_info->message);
 809     n-=GetStringInfoLength(signature_info->message);
 810     TransformSignature(signature_info);
 811   }
 812   (void) CopyMagickMemory(GetStringInfoDatum(signature_info->message),p,n);
 813   signature_info->offset=n;
 814   /*
 815     Reset working registers.
 816   */
 817   i=0;
 818   n=0;
 819   length=0;
 820 }