最近研究了jsp中作HTTP認證的問題，它的工作方式如下：

1、server發送一個要求認證代碼401和一個頭信息WWW-authenticate，激發browser彈出一個認證窗口

2、server取得browser送來的認證頭"Authorization",它是加密的了，要用Base64方法解密，取得明文的用戶名和密碼

3、檢查用戶名和密碼，根據結果傳送不同的頁面

以下是jsp的片斷，你也可以把它做成include文件。和Base64的加解密的class源碼。
如有興趣可與我聯系：[email protected]

<jsp:useBean id="base64"scope="page"class="Base64"/>
<%
if(request.getHeader("Authorization")==null){
   response.setStatus(401);
   response.setHeader("WWW-authenticate","Basic realm=\"unixboy.com\"");
}else{
   String encoded=(request.getHeader("Authorization"));
   String tmp=encoded.substring(6);
   String up=Base64.decode(tmp);
   String user="";
   String password="";
   if(up!=null){
        user=up.substring(0,up.indexOf(":"));
    password=up.substring(up.indexOf(":")+1);
   }
   if(user.equals("unixboy")&&password.equals("123456")){
        //認證成功
   }else{
        //認證失敗
   }
}
%>

//消息加解密class
public class Base64
{
        /** decode a Base 64 encoded String.
          *<p><h4>String to byte conversion</h4>
          * This method uses a naive String to byte interpretation, it simply gets each
          * char of the String and calls it a byte.</p>
          *<p>Since we should be dealing with Base64 encoded Strings that is a reasonable
          * assumption.</p>
          *<p><h4>End of data</h4>
          * We don''t try to stop the converion when we find the"="end of data padding char.
          * We simply add zero bytes to the unencode buffer.</p>
        */
        public static String decode(String encoded)
        {
                StringBuffer sb=new StringBuffer();
                int maxturns;
                //work out how long to loop for.
                if(encoded.length()%3==0)
                maxturns=encoded.length();
                else
                maxturns=encoded.length()+(3-(encoded.length()%3));
                //tells us whether to include the char in the unencode
                boolean skip;
                //the unencode buffer
                byte[] unenc=new byte[4];
                byte b;
                for(int i=0,j=0;i<maxturns;i++)
                {
                        skip=false;
                        //get the byte to convert or 0
                        if(i<encoded.length())
                        b=(byte)encoded.charAt(i);
                        else
                        b=0;
                        //test and convert first capital letters, lowercase, digits then ''+'' and ''/''
                        if(b>=65&&b<91)
                        unenc[j]=(byte)(b-65);
                        else if(b>=97&&b<123)
                        unenc[j]=(byte)(b-71);
                        else if(b>=48&&b<58)
                        unenc[j]=(byte)(b+4);
                        else if(b==''+'')
                        unenc[j]=62;
                        else if(b==''/'')
                        unenc[j]=63;
                        //if we find"="then data has finished, we''re not really dealing with this now
                        else if(b==''='')
                        unenc[j]=0;
                        else
                        {
                                char c=(char)b;
                                if(c==''\n'' c==''\r'' c=='' '' c==''\t'')
                                skip=true;
                                else
                                //could throw an exception here? it''s input we don''t understand.
                                ;
                        }
                        //once the array has boiled convert the bytes back into chars
                        if(!skip&&++j==4)
                        {
                                //shift the 6 bit bytes into a single 4 octet word
                                int res=(unenc[0]<<18)+(unenc[1]<<12)+(unenc[2]<<6)+unenc[3];
                                byte c;
                                int k=16;
                                //shift each octet down to read it as char and add to StringBuffer
                                while(k>=0)
                                {
                                        c=(byte)(res>>k);
                                        if ( c>0 )
                                        sb.append((char)c);
                                        k-=8;
                                }
                                //reset j and the unencode buffer
                                j=0;
                                unenc[0]=0;unenc[1]=0;unenc[2]=0;unenc[3]=0;
                        }
                }
                return sb.toString();
        }
        
        /** encode plaintext data to a base 64 string
          * @param plain the text to convert. If plain is longer than 76 characters this method
          *             returns null (see RFC2045).
          * @return the encoded text (or null if string was longer than 76 chars).
        */
        public static String encode(String plain)
        {
                if(plain.length()>76)
                return null;
                int maxturns;
                StringBuffer sb=new StringBuffer();
                //the encode buffer
                byte[] enc=new byte[3];
                boolean end=false;
                for(int i=0,j=0;!end;i++)
                {
                        char _ch=plain.charAt(i);
                        if(i==plain.length()-1)
                        end=true;
                        enc[j++]=(byte)plain.charAt(i);
                        if(j==3 end)
                        {
                                int res;
                                //this is a bit inefficient at the end point
                                //worth it for the small decrease in code size?
                                res=(enc[0]<<16)+(enc[1]<<8)+enc[2];
                                int b;
                                int lowestbit=18-(j*6);
                                for(int toshift=18;toshift>=lowestbit;toshift-=6)
                                {
                                        b=res>>>toshift;
                                        b&=63;
                                        if(b>=0&&b<26)
                                        sb.append((char)(b+65));
                                        if(b>=26&&b<52)
                                        sb.append((char)(b+71));
                                        if(b>=52&&b<62)
                                        sb.append((char)(b-4));
                                        if(b==62)
                                        sb.append(''+'');
                                        if(b==63)
                                        sb.append(''/'');
                                        if(sb.length()%76==0)
                                        sb.append(''\n'');
                                }
                                //now set the end chars to be pad character if there
                                //was less than integral input (ie: less than 24 bits)
                                if(end)
                                {
                                        if(j==1)
                                        sb.append("==");
                                        if(j==2)
                                        sb.append(''='');
                                }
                                enc[0]=0;enc[1]=0;enc[2]=0;
                                j=0;
                        }
                }
                return sb.toString();
        }
}