org.alfresco.extension.countersign.action.executer.ContentSignatureActionExecuter.java Source code

Introduction

Here is the source code for org.alfresco.extension.countersign.action.executer.ContentSignatureActionExecuter.java

Source

/*
 * Copyright 2012-2013 Alfresco Software Limited.
 * 
 * Licensed under the GNU Affero General Public License, Version 3.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.gnu.org/licenses/agpl-3.0.html
 * 
 * If you do not wish to be bound to the terms of the AGPL v3.0, 
 * A commercial license may be obtained by contacting the author.
 * 
 * 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.
 * 
 * This file is part of an unsupported extension to Alfresco.
 * 
 */
package org.alfresco.extension.countersign.action.executer;

import java.io.ByteArrayInputStream;
import java.io.InputStream;
import java.security.KeyStore;
import java.security.KeyStoreException;
import java.security.NoSuchAlgorithmException;
import java.security.PrivateKey;
import java.security.UnrecoverableKeyException;

import org.alfresco.error.AlfrescoRuntimeException;
import org.alfresco.extension.countersign.model.CounterSignSignatureModel;
import org.alfresco.extension.countersign.service.CounterSignService;
import org.alfresco.extension.countersign.signature.SignatureProvider;
import org.alfresco.model.ContentModel;
import org.alfresco.repo.security.authentication.AuthenticationUtil;
import org.alfresco.service.cmr.action.Action;
import org.alfresco.service.cmr.repository.ContentService;
import org.alfresco.service.cmr.repository.ContentWriter;
import org.alfresco.service.cmr.repository.NodeRef;
import org.alfresco.service.cmr.repository.NodeService;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;

public class ContentSignatureActionExecuter extends AbstractSignatureActionExecuter {

    private static Log logger = LogFactory.getLog(ContentSignatureActionExecuter.class);
    private CounterSignService counterSignService;

    @Override
    protected void executeImpl(Action ruleAction, NodeRef actionedUponNodeRef) {
        NodeService nodeService = serviceRegistry.getNodeService();
        ContentService contentService = serviceRegistry.getContentService();
        byte[] sigBytes;

        if (nodeService.exists(actionedUponNodeRef) == false) {
            return;
        }

        String location = (String) ruleAction.getParameterValue(PARAM_LOCATION);
        String geolocation = (String) ruleAction.getParameterValue(PARAM_GEOLOCATION);
        String reason = (String) ruleAction.getParameterValue(PARAM_REASON);
        String keyPassword = (String) ruleAction.getParameterValue(PARAM_KEY_PASSWORD);

        // get a hash of the document
        InputStream contentStream = contentService.getReader(actionedUponNodeRef, ContentModel.PROP_CONTENT)
                .getContentInputStream();

        try {
            // get the user's private key
            String user = AuthenticationUtil.getRunAsUser();
            SignatureProvider signatureProvider = signatureProviderFactory.getSignatureProvider(user);
            KeyStore keystore = signatureProvider.getUserKeyStore(keyPassword);
            PrivateKey key = (PrivateKey) keystore.getKey(alias, keyPassword.toCharArray());

            // compute the document hash
            byte[] hash = signatureProvider.computeHash(contentStream);

            // sign the hash
            sigBytes = signatureProvider.signHash(hash, keyPassword);

            // create a "signature" node and associate it with the signed doc
            NodeRef sig = addSignatureNodeAssociation(actionedUponNodeRef, location, reason, "none",
                    new java.util.Date(), geolocation, -1, "none");

            // save the signature
            ContentWriter writer = contentService.getWriter(sig, ContentModel.PROP_CONTENT, true);
            writer.putContent(new ByteArrayInputStream(sigBytes));

            // also save the expected hash in the signature
            nodeService.setProperty(sig, CounterSignSignatureModel.PROP_DOCHASH, new String(hash));
        } catch (UnrecoverableKeyException uke) {
            throw new AlfrescoRuntimeException(uke.getMessage());
        } catch (KeyStoreException kse) {
            throw new AlfrescoRuntimeException(kse.getMessage());
        } catch (NoSuchAlgorithmException nsae) {
            throw new AlfrescoRuntimeException(nsae.getMessage());
        } catch (Exception e) {
            throw new AlfrescoRuntimeException(e.getMessage());
        }
    }

    public void setCounterSignService(CounterSignService counterSignService) {
        this.counterSignService = counterSignService;
    }
}