package org.apache.maven.wagon.providers.ssh;

 /*

  * Licensed to the Apache Software Foundation (ASF) under one

  * or more contributor license agreements.  See the NOTICE file

  * distributed with this work for additional information

  * regarding copyright ownership.  The ASF licenses this file

  * to you under the Apache License, Version 2.0 (the

  * "License"); you may not use this file except in compliance

  * with the License.  You may obtain a copy of the License at

  *

  *   http://www.apache.org/licenses/LICENSE-2.0

  *

  * Unless required by applicable law or agreed to in writing,

  * software distributed under the License is distributed on an

  * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY

  * KIND, either express or implied.  See the License for the

  * specific language governing permissions and limitations

  * under the License.

  */

 import org.apache.mina.util.Base64;

 import org.apache.sshd.server.PublickeyAuthenticator;

 import org.apache.sshd.server.session.ServerSession;

 import org.codehaus.plexus.util.IOUtil;

 import javax.crypto.Cipher;

 import java.io.InputStream;

 import java.math.BigInteger;

 import java.security.KeyFactory;

 import java.security.PrivateKey;

 import java.security.PublicKey;

 import java.security.interfaces.RSAPublicKey;

 import java.security.spec.DSAPublicKeySpec;

 import java.security.spec.RSAPublicKeySpec;

 import java.util.ArrayList;

 import java.util.List;

 /**

  * @author Olivier Lamy

  */

 public class TestPublickeyAuthenticator

     implements PublickeyAuthenticator

 {

     public List<PublickeyAuthenticatorRequest> publickeyAuthenticatorRequests =

         new ArrayList<PublickeyAuthenticatorRequest>();

     public boolean keyAuthz;

     public TestPublickeyAuthenticator( boolean keyAuthz )

     {

         this.keyAuthz = keyAuthz;

     }

     public boolean authenticate( String username, PublicKey key, ServerSession session )

     {

         if ( !keyAuthz )

         {

             return false;

         }

         try

         {

             InputStream is =

                 Thread.currentThread().getContextClassLoader().getResourceAsStream( "ssh-keys/id_rsa.pub" );

             PublicKey publicKey = decodePublicKey( IOUtil.toString( is ) );

             publickeyAuthenticatorRequests.add( new PublickeyAuthenticatorRequest( username, key ) );

             return ( (RSAPublicKey) publicKey ).getModulus().equals( ( (RSAPublicKey) publicKey ).getModulus() );

         }

         catch ( Exception e )

         {

             throw new RuntimeException( e.getMessage(), e );

         }

     }

     public static byte[] decrypt( byte[] text, PrivateKey key )

         throws Exception

     {

         byte[] dectyptedText = null;

         Cipher cipher = Cipher.getInstance( "RSA/ECB/PKCS1Padding" );

         cipher.init( Cipher.DECRYPT_MODE, key );

         dectyptedText = cipher.doFinal( text );

         return dectyptedText;

     }

     public static class PublickeyAuthenticatorRequest

     {

         public String username;

         public PublicKey publicKey;

         public PublickeyAuthenticatorRequest( String username, PublicKey publicKey )

         {

             this.username = username;

             this.publicKey = publicKey;

         }

         @Override

         public String toString()

         {

             final StringBuilder sb = new StringBuilder();

             sb.append( "PublickeyAuthenticatorRequest" );

             sb.append( "{username='" ).append( username ).append( '\'' );

             sb.append( ", publicKey=" ).append( publicKey );

             sb.append( '}' );

             return sb.toString();

         }

     }

     private byte[] bytes;

     private int pos;

     public PublicKey decodePublicKey( String keyLine )

         throws Exception

     {

         bytes = null;

         pos = 0;

         for ( String part : keyLine.split( " " ) )

         {

             if ( part.startsWith( "AAAA" ) )

             {

                 bytes = Base64.decodeBase64( part.getBytes() );

                 break;

             }

         }

         if ( bytes == null )

         {

             throw new IllegalArgumentException( "no Base64 part to decode" );

         }

         String type = decodeType();

         if ( type.equals( "ssh-rsa" ) )

         {

             BigInteger e = decodeBigInt();

             BigInteger m = decodeBigInt();

             RSAPublicKeySpec spec = new RSAPublicKeySpec( m, e );

             return KeyFactory.getInstance( "RSA" ).generatePublic( spec );

         }

         else if ( type.equals( "ssh-dss" ) )

         {

             BigInteger p = decodeBigInt();

             BigInteger q = decodeBigInt();

             BigInteger g = decodeBigInt();

             BigInteger y = decodeBigInt();

             DSAPublicKeySpec spec = new DSAPublicKeySpec( y, p, q, g );

             return KeyFactory.getInstance( "DSA" ).generatePublic( spec );

         }

         else

         {

             throw new IllegalArgumentException( "unknown type " + type );

         }

     }

     private String decodeType()

     {

         int len = decodeInt();

         String type = new String( bytes, pos, len );

         pos += len;

         return type;

     }

     private int decodeInt()

     {

         return ( ( bytes[pos++] & 0xFF ) << 24 ) | ( ( bytes[pos++] & 0xFF ) << 16 ) | ( ( bytes[pos++] & 0xFF ) << 8 )

             | ( bytes[pos++] & 0xFF );

     }

     private BigInteger decodeBigInt()

     {

         int len = decodeInt();

         byte[] bigIntBytes = new byte[len];

         System.arraycopy( bytes, pos, bigIntBytes, 0, len );

         pos += len;

         return new BigInteger( bigIntBytes );

     }

 }