package org.apache.commons.openpgp;

 /*

  * 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 java.io.IOException;

 import java.io.InputStream;

 import java.security.Security;

 import java.security.SignatureException;

 import org.bouncycastle.jce.provider.BouncyCastleProvider;

 import org.bouncycastle.openpgp.PGPCompressedData;

 import org.bouncycastle.openpgp.PGPException;

 import org.bouncycastle.openpgp.PGPObjectFactory;

 import org.bouncycastle.openpgp.PGPPublicKey;

 import org.bouncycastle.openpgp.PGPSignature;

 import org.bouncycastle.openpgp.PGPSignatureList;

 import org.bouncycastle.openpgp.PGPUtil;

 import org.bouncycastle.openpgp.operator.jcajce.JcaPGPContentVerifierBuilderProvider;

 /**

  * Bouncy Castle implementation of the OpenPGP signer.

  * 

  * @author <a href="mailto:brett@apache.org">Brett Porter</a>

  */

 public class BouncyCastleOpenPgpStreamingSignatureVerifier

     implements OpenPgpStreamingSignatureVerifier

 {

     private PGPSignature sig;

     public BouncyCastleOpenPgpStreamingSignatureVerifier( InputStream signature, KeyRing keyRing )

         throws OpenPgpException, IOException

     {

         init( signature, keyRing );

     }

     private void init( InputStream signature, KeyRing keyRing )

         throws OpenPgpException, IOException

     {

         // TODO: better location for this?

         Security.addProvider( new BouncyCastleProvider() );

         try

         {

             signature = PGPUtil.getDecoderStream( signature );

             PGPPublicKey key = null;

             while ( key == null && signature.available() > 0 )

             {

                 PGPObjectFactory pgpFact = new PGPObjectFactory( signature );

                 PGPSignatureList p3;

                 Object o = pgpFact.nextObject();

                 if ( o == null )

                 {

                     break;

                 }

                 if ( o instanceof PGPCompressedData )

                 {

                     PGPCompressedData c1 = (PGPCompressedData) o;

                     pgpFact = new PGPObjectFactory( c1.getDataStream() );

                     p3 = (PGPSignatureList) pgpFact.nextObject();

                 }

                 else

                 {

                     p3 = (PGPSignatureList) o;

                 }

                 for ( int i = 0; i < p3.size(); i++ )

                 {

                     sig = p3.get( i );

                     key = keyRing.getPublicKey( sig.getKeyID() );

                     if ( key != null )

                     {

                         break;

                     }

                     else

                     {

                         // TODO: log them all

                     }

                 }

             }

             if ( key == null )

             {

                 throw new UnknownKeyException( "Unable to find key with key ID '"

                     + Long.toHexString( sig.getKeyID() ).toUpperCase() + "' in public key ring" );

             }

             sig.init(new JcaPGPContentVerifierBuilderProvider().setProvider("BC"), key);

         }

         catch ( PGPException e )

         {

             // TODO: more details

             throw new OpenPgpException( "Error calculating detached signature", e );

         }

     }

     public void update( byte[] buf )

         throws OpenPgpException

     {

         update( buf, 0, buf.length );

     }

     public void update( byte[] buf, int offset, int length )

         throws OpenPgpException

     {

         try

         {

             sig.update( buf, offset, length );

         }

         catch ( SignatureException e )

         {

             // TODO: more details

             throw new OpenPgpException( "Error calculating detached signature", e );

         }

     }

     public SignatureStatus finish()

         throws OpenPgpException, IOException

     {

         try

         {

             if ( sig.verify() )

             {

                 // TODO: how do we assess trust?

                 return SignatureStatus.VALID_UNTRUSTED;

             }

             else

             {

                 return SignatureStatus.INVALID;

             }

         }

         catch ( PGPException e )

         {

             // TODO: more details

             throw new OpenPgpException( "Error calculating detached signature", e );

         }

         catch ( SignatureException e )

         {

             // TODO: more details

             throw new OpenPgpException( "Error calculating detached signature", e );

         }

     }

 }