Criptografia

Publicado por amim 15/04/2004

[ Hits: 8.108 ]

Download Md5.java




Esse algoritimo é muito bom, o MD5 é um algoritimo unidirecional ou seja você não consegue decriptografar a senha apenas compara-las, ele é usado na maioria das vezes no FreeBSD. É um algoritimo também usado na comparação do tamanho de arquivos, e mesmo assim é mais confiável do que o DES. Todos os direitos reservados (c) COPYRIGHT MIT and INRIA, 1996.

  



Esconder código-fonte

// Md5.java
// $Id: Md5.java,v 1.5 2000/08/16 21:37:48 ylafon Exp $
// (c) COPYRIGHT MIT and INRIA, 1996.
// Please first read the full copyright statement in file COPYRIGHT.html

package org.w3c.tools.crypt ;

import java.io.ByteArrayInputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintStream;
import java.io.UnsupportedEncodingException;

public class Md5 {
    private static final int BUFFER_SIZE = 1024 ;

    private static final int S11 = 7 ;
    private static final int S12 = 12 ;
    private static final int S13 = 17 ;
    private static final int S14 = 22 ;
    private static final int S21 = 5 ;
    private static final int S22 = 9 ;
    private static final int S23 = 14 ;
    private static final int S24 = 20 ;
    private static final int S31 = 4 ;
    private static final int S32 = 11 ;
    private static final int S33 = 16 ;
    private static final int S34 = 23 ;
    private static final int S41 = 6 ;
    private static final int S42 = 10 ;
    private static final int S43 = 15 ;
    private static final int S44 = 21 ;

    private static byte padding[] = {
   (byte) 0x80, (byte) 0, (byte) 0, (byte) 0, (byte) 0, (byte) 0,
   (byte) 0, (byte) 0, (byte) 0, (byte) 0, (byte) 0, (byte) 0,
   (byte) 0, (byte) 0, (byte) 0, (byte) 0, (byte) 0, (byte) 0,
   (byte) 0, (byte) 0, (byte) 0, (byte) 0, (byte) 0, (byte) 0, 
   (byte) 0, (byte) 0, (byte) 0, (byte) 0, (byte) 0, (byte) 0, 
   (byte) 0, (byte) 0, (byte) 0, (byte) 0, (byte) 0, (byte) 0, 
   (byte) 0, (byte) 0, (byte) 0, (byte) 0, (byte) 0, (byte) 0, 
   (byte) 0, (byte) 0, (byte) 0, (byte) 0, (byte) 0, (byte) 0, 
   (byte) 0, (byte) 0, (byte) 0, (byte) 0, (byte) 0, (byte) 0, 
   (byte) 0, (byte) 0, (byte) 0, (byte) 0, (byte) 0, (byte) 0, 
   (byte) 0, (byte) 0, (byte) 0, (byte) 0
    } ;

    private InputStream in       = null ;
    private boolean     stringp  = false ;
    private int         state[]  = null ;
    private long        count    = 0 ;
    private byte        buffer[] = null ;
    private byte        digest[] = null ;

    private static String stringify (byte buf[]) {
   StringBuffer sb = new StringBuffer(2*buf.length) ;
   for (int i = 0 ; i < buf.length; i++) {
       int h = (buf[i] & 0xf0) >> 4 ;
       int l = (buf[i] & 0x0f) ;
       sb.append (new Character((char)((h>9) ? 'a'+h-10 : '0'+h))) ;
       sb.append (new Character((char)((l>9) ? 'a'+l-10 : '0'+l))) ;
   }
   return sb.toString() ;
    }

    private final int F(int x, int y, int z) {
   return ((x & y) | ((~x) & z)) ;
    }

    private final int G(int x, int y, int z) {
   return ((x & z) | (y & (~z))) ;
    }

    private final int H(int x, int y, int z) {
   return (x ^ y ^ z) ;
    }

    private final int I(int x, int y, int z) {
   return (y ^ (x | (~z))) ;
    }

    private final int  rotate_left(int x, int n) {
   return ((x << n) | (x >>> (32-n))) ;
    }

    private final int FF(int a,int b,int c,int d,int x,int s,int ac) {
   a += (F(b, c, d) + x + ac) ;
   a = rotate_left(a, s) ;
   a += b ;
   return a ;
    }

    private final int GG(int a,int b,int c,int d,int x,int s,int ac) {
   a += (G(b, c, d) + x + ac) ;
   a = rotate_left(a, s) ;
   a += b ;
   return a ;
    }

    private final int HH(int a,int b,int c,int d,int x,int s,int ac) {
   a += (H(b, c, d) + x + ac) ;
   a = rotate_left(a, s) ;
   a += b ;
   return a ;
    }

    private final int II(int a,int b,int c,int d,int x,int s,int ac) {
   a += (I(b, c, d) + x + ac) ;
   a = rotate_left(a, s) ;
   a += b ;
   return a;
    }

    private final void decode (int output[], byte input[], int off, int len) {
   int i = 0 ;
   int j = 0 ;
   for ( ; j < len; i++, j += 4) {
       output[i] = (((int) (input[off+j]&0xff))
          | (((int) (input[off+j+1] & 0xff)) << 8)
          | (((int) (input[off+j+2] & 0xff)) << 16)
          | (((int) (input[off+j+3] & 0xff)) << 24)) ;
   }
    }

    private final void transform (byte block[], int offset) {
   int a   = state[0] ;
   int b   = state[1] ;
   int c   = state[2] ;
   int d   = state[3] ;
   int x[] = new int[16] ;

   decode (x, block, offset, 64);
   /* Round 1 */
   a = FF (a, b, c, d, x[ 0], S11, 0xd76aa478); /* 1 */
   d = FF (d, a, b, c, x[ 1], S12, 0xe8c7b756); /* 2 */
   c = FF (c, d, a, b, x[ 2], S13, 0x242070db); /* 3 */
   b = FF (b, c, d, a, x[ 3], S14, 0xc1bdceee); /* 4 */
   a = FF (a, b, c, d, x[ 4], S11, 0xf57c0faf); /* 5 */
   d = FF (d, a, b, c, x[ 5], S12, 0x4787c62a); /* 6 */
   c = FF (c, d, a, b, x[ 6], S13, 0xa8304613); /* 7 */
   b = FF (b, c, d, a, x[ 7], S14, 0xfd469501); /* 8 */
   a = FF (a, b, c, d, x[ 8], S11, 0x698098d8); /* 9 */
   d = FF (d, a, b, c, x[ 9], S12, 0x8b44f7af); /* 10 */
   c = FF (c, d, a, b, x[10], S13, 0xffff5bb1); /* 11 */
   b = FF (b, c, d, a, x[11], S14, 0x895cd7be); /* 12 */
   a = FF (a, b, c, d, x[12], S11, 0x6b901122); /* 13 */
   d = FF (d, a, b, c, x[13], S12, 0xfd987193); /* 14 */
   c = FF (c, d, a, b, x[14], S13, 0xa679438e); /* 15 */
   b = FF (b, c, d, a, x[15], S14, 0x49b40821); /* 16 */
   /* Round 2 */
   a = GG (a, b, c, d, x[ 1], S21, 0xf61e2562); /* 17 */
   d = GG (d, a, b, c, x[ 6], S22, 0xc040b340); /* 18 */
   c = GG (c, d, a, b, x[11], S23, 0x265e5a51); /* 19 */
   b = GG (b, c, d, a, x[ 0], S24, 0xe9b6c7aa); /* 20 */
   a = GG (a, b, c, d, x[ 5], S21, 0xd62f105d); /* 21 */
   d = GG (d, a, b, c, x[10], S22,  0x2441453); /* 22 */
   c = GG (c, d, a, b, x[15], S23, 0xd8a1e681); /* 23 */
   b = GG (b, c, d, a, x[ 4], S24, 0xe7d3fbc8); /* 24 */
   a = GG (a, b, c, d, x[ 9], S21, 0x21e1cde6); /* 25 */
   d = GG (d, a, b, c, x[14], S22, 0xc33707d6); /* 26 */
   c = GG (c, d, a, b, x[ 3], S23, 0xf4d50d87); /* 27 */
   b = GG (b, c, d, a, x[ 8], S24, 0x455a14ed); /* 28 */
   a = GG (a, b, c, d, x[13], S21, 0xa9e3e905); /* 29 */
   d = GG (d, a, b, c, x[ 2], S22, 0xfcefa3f8); /* 30 */
   c = GG (c, d, a, b, x[ 7], S23, 0x676f02d9); /* 31 */
   b = GG (b, c, d, a, x[12], S24, 0x8d2a4c8a); /* 32 */
   
   /* Round 3 */
   a = HH (a, b, c, d, x[ 5], S31, 0xfffa3942); /* 33 */
   d = HH (d, a, b, c, x[ 8], S32, 0x8771f681); /* 34 */
   c = HH (c, d, a, b, x[11], S33, 0x6d9d6122); /* 35 */
   b = HH (b, c, d, a, x[14], S34, 0xfde5380c); /* 36 */
   a = HH (a, b, c, d, x[ 1], S31, 0xa4beea44); /* 37 */
   d = HH (d, a, b, c, x[ 4], S32, 0x4bdecfa9); /* 38 */
   c = HH (c, d, a, b, x[ 7], S33, 0xf6bb4b60); /* 39 */
   b = HH (b, c, d, a, x[10], S34, 0xbebfbc70); /* 40 */
   a = HH (a, b, c, d, x[13], S31, 0x289b7ec6); /* 41 */
   d = HH (d, a, b, c, x[ 0], S32, 0xeaa127fa); /* 42 */
   c = HH (c, d, a, b, x[ 3], S33, 0xd4ef3085); /* 43 */
   b = HH (b, c, d, a, x[ 6], S34,  0x4881d05); /* 44 */
   a = HH (a, b, c, d, x[ 9], S31, 0xd9d4d039); /* 45 */
   d = HH (d, a, b, c, x[12], S32, 0xe6db99e5); /* 46 */
   c = HH (c, d, a, b, x[15], S33, 0x1fa27cf8); /* 47 */
   b = HH (b, c, d, a, x[ 2], S34, 0xc4ac5665); /* 48 */
   
   /* Round 4 */
   a = II (a, b, c, d, x[ 0], S41, 0xf4292244); /* 49 */
   d = II (d, a, b, c, x[ 7], S42, 0x432aff97); /* 50 */
   c = II (c, d, a, b, x[14], S43, 0xab9423a7); /* 51 */
   b = II (b, c, d, a, x[ 5], S44, 0xfc93a039); /* 52 */
   a = II (a, b, c, d, x[12], S41, 0x655b59c3); /* 53 */
   d = II (d, a, b, c, x[ 3], S42, 0x8f0ccc92); /* 54 */
   c = II (c, d, a, b, x[10], S43, 0xffeff47d); /* 55 */
   b = II (b, c, d, a, x[ 1], S44, 0x85845dd1); /* 56 */
   a = II (a, b, c, d, x[ 8], S41, 0x6fa87e4f); /* 57 */
   d = II (d, a, b, c, x[15], S42, 0xfe2ce6e0); /* 58 */
   c = II (c, d, a, b, x[ 6], S43, 0xa3014314); /* 59 */
   b = II (b, c, d, a, x[13], S44, 0x4e0811a1); /* 60 */
   a = II (a, b, c, d, x[ 4], S41, 0xf7537e82); /* 61 */
   d = II (d, a, b, c, x[11], S42, 0xbd3af235); /* 62 */
   c = II (c, d, a, b, x[ 2], S43, 0x2ad7d2bb); /* 63 */
   b = II (b, c, d, a, x[ 9], S44, 0xeb86d391); /* 64 */

   state[0] += a;
   state[1] += b;
   state[2] += c;
   state[3] += d;
    }

    private final void update (byte input[], int len) {
   int index = ((int) (count >> 3)) & 0x3f ;
   count += (len << 3) ;
   int partLen = 64 - index ;
   int i = 0 ;
   if ( len >= partLen ) {
       System.arraycopy (input, 0, buffer, index, partLen) ;
       transform (buffer, 0) ;
       for (i = partLen ; i + 63 < len ; i+= 64) 
      transform (input, i) ;
       index = 0 ;
   } else {
       i = 0 ;
   }
   System.arraycopy (input, i, buffer, index, len - i) ;
    }

    private byte[] end () {
   byte bits[] = new byte[8] ;
   for (int i = 0 ; i < 8 ; i++)
       bits[i] = (byte) ((count>>>(i*8)) & 0xff) ;
   int index  = ((int) (count >> 3)) & 0x3f ;
   int padlen = (index < 56) ? (56 - index) : (120 - index) ;
   update (padding, padlen) ;
   update (bits, 8) ;
   return encode(state, 16) ;
    }

    // Encode the content.state array into 16 bytes array
    private byte[] encode (int input[], int len) {
   byte output[] = new byte[len] ;
   int i = 0 ;
   int j = 0 ;
   for ( ; j < len ; i++, j+= 4) {
       output[j]   = (byte) ((input[i]      ) & 0xff) ;
       output[j+1] = (byte) ((input[i] >> 8 ) & 0xff) ;
       output[j+2] = (byte) ((input[i] >> 16) & 0xff) ;
       output[j+3] = (byte) ((input[i] >> 24) & 0xff) ;
   }
   return output ;
    }

    /**
     * Get the digest for our input stream.
     * This method constructs the input stream digest, and return it, as a
     * a String, following the MD5 (rfc1321) algorithm,
     * @return An instance of String, giving the message digest.
     * @exception IOException Thrown if the digestifier was unable to read the
     *    input stream.
     */

    public byte[] getDigest ()
   throws IOException 
    {
   byte buffer[] = new byte[BUFFER_SIZE] ;
   int  got      = -1 ;

   if ( digest != null )
       return digest ;
   while ((got = in.read(buffer)) > 0 ) 
       update (buffer, got) ;
   this.digest = end () ;
   return digest ;
    }

    /**
     * Get the digest, for this string digestifier.
     * This method doesn't throw any IOException, since it knows that the
     * underlying stream ws built from a String.
     */

    public byte[] processString () {
   if ( ! stringp ) 
       throw new RuntimeException (this.getClass().getName()
               + "[processString]"
               + " not a string.") ;
   try {
       return getDigest() ;
   } catch (IOException ex) {
   }
   throw new RuntimeException (this.getClass().getName()
                + "[processString]"
                + ": implementation error.") ;
    }

    /**
     * Get the digest, as a proper string.
     */

    public String getStringDigest() {
   if ( digest == null )
       throw new RuntimeException (this.getClass().getName()
               + "[getStringDigest]"
               + ": called before processing.") ;
   return stringify (digest) ;
    }

    /**
     * Construct a digestifier for the given string.
     * @param input The string to be digestified.
     * @param encoding the encoding name used (such as UTF8)
     */

    public Md5 (String input, String enc) {
    byte bytes [] = null;
   try {
       bytes = input.getBytes (enc);
   } catch(UnsupportedEncodingException e){
       throw new RuntimeException("no "+enc+" encoding!!!");
   }
   this.stringp = true ;
   this.in      = new ByteArrayInputStream (bytes) ;
   this.state   = new int[4] ;
   this.buffer  = new byte[64] ;
   this.count   = 0 ;
   state[0] = 0x67452301;
   state[1] = 0xefcdab89;
   state[2] = 0x98badcfe;
   state[3] = 0x10325476;
    }   

    /**
     * Construct a digestifier for the given string.
     * @param input The string to be digestified.
     */

    public Md5 (String input) {
   this(input, "UTF8");
    }

    /**
     * Construct a digestifier for the given input stream.
     * @param in The input stream to be digestified.
     */

    public Md5 (InputStream in) {
   this.stringp = false ;
   this.in      = in ;
   this.state   = new int[4] ;
   this.buffer  = new byte[64] ;
   this.count   = 0 ;
   state[0] = 0x67452301;
   state[1] = 0xefcdab89;
   state[2] = 0x98badcfe;
   state[3] = 0x10325476;
    }

    public static void main (String args[]) 
   throws IOException
    {
   if ( args.length != 1) {
       System.out.println ("Md5 <file>") ;
       System.exit (1) ;
   }
   Md5 md5 = new Md5 (new FileInputStream(new File(args[0]))) ;
   byte b[]= md5.getDigest();
   System.out.println (stringify(b)) ;
    }

}

Scripts recomendados

Simples PortScan

Login Java web com MySQL com criptografia MD5

planetas

JCriptoCesar, a cifra de Cesar em Java

Criptografia com MD5


  

Comentários

Nenhum comentário foi encontrado.


Contribuir com comentário




Patrocínio

Site hospedado pelo provedor RedeHost.
Linux banner

Destaques

Artigos

Dicas

Tópicos

Top 10 do mês

Scripts