SHA-1

Ne kriptografi, **SHA-1** është një funksion hash kriptografik dizajnuar prej National Security Agency te shteteve te bashkuara te Amerikës (SHBA)  dhe është  Standardi për Procesimin e Informatave Shtetërore publikuar nga  NIST.

SHA-1 gjeneron një vlere 160-bit (20-byte) për hash. Vlera e SHA-1 hash-it, zakonisht është e dhëne si numër hexadecimal, 40 karaktere i gjate.

SHA është akronim për "algoritëm hash për siguri". Katër SHA algoritmet janë strukturuar ne mënyra te ndryshme dhe janë emëruar *SHA-0*, *SHA-1*, *SHA-2*, dhe *SHA-3*. SHA-0 është versioni origjinal 160-bit i HASH funksionit, publikuar me 1993 i emëruar si "SHA": nuk u adoptua nga shume aplikacione. Publikuar me 1995, SHA-1 është shume i ngjashëm me SHA-0, por ndryshon origjinalin SHA hashin dhe rregullon specifikat duke permisuar dobësitë. SHA-2, i publikuar me 2001, është i ndryshëm prej SHA-1 funksionit.
SHA-1 është me i përdoruri dhe me i përhapuri nga SHA hash funksionet, dhe është i përfshire ne shume aplikacione dhe protokole qe përdoren.
Me 2005, kriptoanalistet zbuluan një sulm ne SHA-1 duke propozuar se algoritmi nuk është i sigurt sa duhet për përdorim te mëtutjeshëm. NIST kërkoi se shume aplikacione te agjencisë federale te kalojnë ne SHA-2 pasi qe ne 2010 u zbulua ajo dobesi. Edhe pse as një sulm nuk është raportuar te ketë pasur sukses ne SHA-2, pasi qe algoritmi i tij ka ngjashmëri me SHA-1. Me 2012, pas një konkurrence te gjate NIST zgjodhi algoritmin Keccak, për standardizim ne vend te SHA-3. Ne nëntor te vitit 2013  Microsoft paraqiti politiken e tij ne SHA-1 bazuar ne ketë Windows-i nuk do i pranoj me certifikatat e SHA-1 ne SSL me 2017. Ne shtator 2014Google paraqiti politikat e saj për SHA-1 sipas saj Chrome do vazhdoj ti pranoj SHA-1 certifikatat me SSL edhe gjate pas 2017 Mozillagjithashtu po planifikon te ndaloj pranimin e SHA-1-certifikatave me SSL rreth vitit 2017.

## SHA-1 hash funksioni
  of the state;
*F* is a nonlinear function that varies;
*n* denotes a left bit rotation by *n* places;
*n* varies for each operation;
Wt is the expanded message word of round t;
Kt is the round constant of round t;
 denotes addition modulo 232.]]

SHA-1 krijon një tretje te mesazhit bazuar ne principe te ngjashme te përdorura nga Ronald L. Rivest prej MIT ne dizajnimin e MD4 dhe MD5 algoritmeve për tretës se tekstit, por ka një dizajnë me te kujdesshëm.
Specifikimi origjinal i algoritmit është publikuar me 1993 me titullin "Secure Hash Standard" , FIPS PUB 180, me standarde te qeverise nga agjencia NIST(Instituti Nacional p
për Standarde Teknologjike). Ky version shpesh emërohet si SHA-0.

## Aplikimet
## Shembuj te kodimit
### Shembuj te hasheve
Këta janë shembuj te SHA-1 tretësit se mesazhit ne hexadecimal dhe ne Base64 binar ne  ASCII  enkodim te tekstit.

 SHA1("The quick brown fox jumps over the lazy og")
 gives hexadecimal: 2fd4e1c67a2d28fced849ee1bb76e7391b93eb12
 gives Base64 binary to ASCII text encoding: L9ThxnotKPzthJ7hu3bnORuT6xI=
Edhe një ndryshim i vogël ne mesazh do te bej ndryshime te mëdha ne rezultat, duke bere komplet një hash kodit tjetër. Për shembull duke ndryshuar `dog` to `cog` krijon një hash me diference prej me shume se 81 prej 160:

 SHA1("The quick brown fox jumps over the lazy og")
 gives hexadecimal: de9f2c7fd25e1b3afad3e85a0bd17d9b100db4b3
 gives Base64 binary to ASCII text encoding: 3p8sf9JeGzr60+haC9F9mxANtLM=

Hashi i teksti pa asnjë karakter është :

 SHA1("")
 gives hexadecimal: da39a3ee5e6b4b0d3255bfef95601890afd80709
 gives Base64 binary to ASCII text encoding: 2jmj7l5rSw0yVb/vlWAYkK/YBwk=

### SHA-1 Kodimi
Kodi për  SHA-1 algoritmin është:

 *Note 1: All variables are unsigned 32 bits and wrap modulo 232 when calculating, except*
         *ml the message length which is 64 bits, and*
         *hh the message digest which is 160 bits.*
 *Note 2: All constants in this pseudo code are in big endian.*
         *Within each word, the most significant byte is stored in the leftmost byte position*
 
 *Initialize variables:*
 
 h0 = 0x67452301
 h1 = 0xEFCDAB89
 h2 = 0x98BADCFE
 h3 = 0x10325476
 h4 = 0xC3D2E1F0
 
 ml = message length in bits (always a multiple of the number of bits in a character).
 
 *Pre-processing:*
 append the bit '1' to the message i.e. by adding 0x80 if characters are 8 bits. 
 append 0 ≤ k &lt; 512 bits '0', thus the resulting message length (in *bits*)
    is congruent to 448 (mod 512)
 append ml, in a 64-bit big-endian integer. So now the message length is a multiple of 512 bits.
 
 *Process the message in successive 512-bit chunks:*
 break message into 512-bit chunks
 **for** each chunk
     break chunk into sixteen 32-bit big-endian words w[i], 0 ≤ i ≤ 15
 
     *Extend the sixteen 32-bit words into eighty 32-bit words:*
     **for** i **from** 16 to 79
         w[i] = (w[i-3] **xor** w[i-8] **xor** w[i-14] **xor** w[i-16]) **leftrotate** 1
 
     *Initialize hash value for this chunk:*
     a = h0
     b = h1
     c = h2
     d = h3
     e = h4
 
     *Main loop:*
     **for** i **from** 0 **to** 79
         **if** 0 ≤ i ≤ 19 **then**
             f = (b **and** c) **or** ((**not** b) **and** d)
             k = 0x5A827999
         **else if** 20 ≤ i ≤ 39
             f = b **xor** c **xor** d
             k = 0x6ED9EBA1
         **else if** 40 ≤ i ≤ 59
             f = (b **and** c) **or** (b **and** d) **or** (c **and** d) 
             k = 0x8F1BBCDC
         **else if** 60 ≤ i ≤ 79
             f = b **xor** c **xor** d
             k = 0xCA62C1D6
 
         temp = (a **leftrotate** 5) + f + e + k + w[i]
         e = d
         d = c
         c = b **leftrotate** 30
         b = a
         a = temp
 
     ''Add this chunk's hash to result so far:*
     h0 = h0 + a
     h1 = h1 + b 
     h2 = h2 + c
     h3 = h3 + d
     h4 = h4 + e
 
 *Produce the final hash value (big-endian) as a 160 bit number:*
 hh = (h0 **leftshift** 128) **or** (h1 **leftshift** 96) **or** (h2 **leftshift** 64) **or** (h3 **leftshift** 32) **or** h4

Numri hh ne mesazh është mbetje, e cila mund te shkruhet ne forme heksadecimale(base 16), por me se shpeshti shkruhet si Base64 binar me enkodimin ne ASCII tekst.

Ne vende te formulimit origjinal te FIPS PUB 180-1 , funksione te ngjashme mund te paraqiten per gjetjen e `f` ne unazën kryesore sipër.

 (0  ≤ i ≤ 19): f = d **xor** (b **and** (c **xor** d))                *(alternative 1)*
 (0  ≤ i ≤ 19): f = (b **and** c) **xor** ((**not** b) **and** d)          *(alternative 2)*
 (0  ≤ i ≤ 19): f = (b **and** c) + ((**not** b) **and** d)            *(alternative 3)*
 (0  ≤ i ≤ 19): f = vec_sel(d, c, b)                       *(alternative 4)*
 &nbsp;
 (40 ≤ i ≤ 59): f = (b **and** c) **or** (d **and** (b **or** c))          *(alternative 1)*
 (40 ≤ i ≤ 59): f = (b **and** c) **or** (d **and** (b **xor** c))         *(alternative 2)*
 (40 ≤ i ≤ 59): f = (b **and** c) + (d **and** (b **xor** c))          *(alternative 3)*
 (40 ≤ i ≤ 59): f = (b **and** c) **xor** (b **and** d) **xor** (c **and** d)  *(alternative 4)*
 (40 ≤ i ≤ 59): f = vec_sel(c, b, c **xor** d)                 *(alternative 5)''

Max Locktyukhin ka shfaqur se per roundet 32-79 llogaritja e:

 w[i] = (w[i-3] **xor** w[i-8] **xor** w[i-14] **xor** w[i-16]) **leftrotate** 1

mund te zavendesohet me:

 w[i] = (w[i-6] **xor** w[i-16] **xor** w[i-28] **xor** w[i-32]) **leftrotate** 2

Ky transformim mban te gjith operatoret 64-bit , duke larguar mbetjet e  `w[i]` on `w[i-3]`,lejon ne menyre eficiente imlepentimin e x86 SSE instruksioneve.

.

## See also 
* Comparison of cryptographic hash functions
* cryptlib
* Crypto++
* Digital timestamping
* Hashcash
* Hash collision
* International Association for Cryptologic Research
* Libgcrypt
* md5deep
* OpenSSL
* PolarSSL
* RIPEMD-160
* Secure Hash Standard
* sha1sum
* Tiger (cryptography)
* Whirlpool (cryptography)

## Notes 
## References 
* Florent Chabaud, Antoine Joux: Differential Collisions in SHA-0. CRYPTO 1998. pp56–71
* Eli Biham, Rafi Chen, Near-Collisions of SHA-0, Cryptology ePrint Archive, Report 2004/146, 2004 (appeared on CRYPTO 2004), IACR.org
* Xiaoyun Wang, Hongbo Yu and Yiqun Lisa Yin, Efficient Collision Search Attacks on SHA-0, CRYPTO 2005, CMU.edu
* Xiaoyun Wang, Yiqun Lisa Yin and Hongbo Yu, Finding Collisions in the Full SHA-1, Crypto 2005 MIT.edu
* Henri Gilbert, Helena Handschuh: Security Analysis of SHA-256 and Sisters. Selected Areas in Cryptography 2003: pp175–193
*http://www.unixwiz.net/techtips/iguide-crypto-hashes.html
* 
* A. Cilardo, L. Esposito, A. Veniero, A. Mazzeo, V. Beltran, E. Ayugadé, A CellBE-based HPC application for the analysis of vulnerabilities in cryptographic hash functions, High Performance Computing and Communication international conference, August 2010

## External links
* CSRC Cryptographic Toolkit – Official NIST site for the Secure Hash Standard
* FIPS 180-4: Secure Hash Standard (SHS)  (PDF, 1.7 MB) – Current version of the Secure Hash Standard (SHA-1, SHA-224, SHA-256, SHA-384, and SHA-512), March 2012
* RFC 3174 (with sample C implementation)
* Interview with Yiqun Lisa Yin concerning the attack on SHA-1
* Explanation of the successful attacks on SHA-1 (3 pages, 2006)
* Cryptography Research – Hash Collision Q&amp;A
* Online SHA1 hash crack using Rainbow tables
* Hash Project Web Site: software- and hardware-based cryptanalysis of SHA-1
* 
*  by Christof Paar