pdfsigner

#!/bin/bash

umask 0002
MYCUSTOMTAB='     '
readonly NC='\033[0m'
readonly RED='\033[0;31m' 
readonly DIR_SCRIPT=$(dirname "$0")
readonly FMT_DATE_OLD="+%Y%m%d%H%M%S"
readonly FMT_DATE="+%d/%m/%Y-%H:%M:%S"
readonly CMD_DATE="LC_ALL=pt_BR.utf8 date ${FMT_DATE}"
readonly OUTPUT_DIR=/home/bgstudios/pdfsigner-output
  
[ ! -d "${OUTPUT_DIR}" ] && mkdir -pv "${OUTPUT_DIR}"

#######################
## DEPENDÊNCIAS
###################

## JAVA
if ! [ -x "$(command -v java)" ]; then
  echo "Comando 'java' nao instalado!"
  exit 2
fi

## OPENSSL
if ! [ -x "$(command -v openssl)" ]; then
  echo "Comando 'openssl' nao instalado!"
  exit 2
fi

## PDFSIG
if ! [ -x "$(command -v pdfsig)" ]; then
  echo "Comando 'pdfsig' nao instalado!"
  exit 2
fi

#######################
## FUNÇÕES
###################

help() {
cat << EOF
Como usar: ${0##*/} [-h] ou [-s PFX SENHA PDF LOCALIZADOR] ou [-x PFX SENHA LOCALIZADOR] ou [-p PDF LOCALIZADOR]
Assine um PDF com um Certificado PFX. Verifique um certificado. Verifique um pdf assinado.

    -h | --help                             exibe esta ajuda.
    -x | --pfx    PFX SENHA LOCALIZADOR     verifica um certificado PFX.
    -s | --sign   PFX SENHA PDF LOCALIZADOR assina um arquivo PDF com o CERTIFICADO PFX
                                            caso ainda não esteja assinado.
    -p | --pdf    PDF LOCALIZADOR           verifica a assinatura de um arquivo PDF.
EOF
}

## FUNÇÃO: ASSINA UM ARQUIVO PDF COM CERTIFICADO PFX
##
## pdf_sign CERT PASSWORD PDF LOCALIZADOR
##
## retorna 
##	1 se assinado
##	0 se falhou
##
function pdf_sign {
  CERT="$1"
  PASSWORD="$2"
  PDF="$3"
  LOCALIZADOR="$4"
  JSON="${OUTPUT_DIR}/${LOCALIZADOR}.json"
  PDF_SIGNED="${OUTPUT_DIR}/${LOCALIZADOR}.pdf"
  IS_PDF=`file "${PDF}" | fgrep -c PDF\ document`

  pfx_owner "${CERT}" "${PASSWORD}"

  if [ ! -s "${PDF}" ]
  then
    json "falha" "" "`eval ${CMD_DATE}`" "${nome}" "${doc}" "O arquivo nao existe" "${LOCALIZADOR}" ""
    return 0
  fi

  if [ ! "${PDF: -4}" == ".pdf" ] || [ $((${IS_PDF})) -eq 0 ]
  then
    json "falha" "" "`eval ${CMD_DATE}`" "${nome}" "${doc}" "O arquivo deve ser um PDF" "${LOCALIZADOR}" ""
    return 0
  fi

  if [ ${#LOCALIZADOR} -eq 0 ]
  then
    json "falha" "" "`eval ${CMD_DATE}`" "${nome}" "${doc}" "O localizador não foi informado" "localizador_nao_informado" ""
    return 0
  fi

  if [ ! -s "${PDF_SIGNED}" ]
  then
    pfx_json=`pfx_check "${CERT}" "${PASSWORD}" "${LOCALIZADOR}"`
    pfx_result=$?
    if [ ${pfx_result} -eq 0 ]
    then
      [ -s "${PDF_SIGNED}" ] && rm -f "${PDF_SIGNED}"
      cd ${DIR_SCRIPT}
      export CLASSPATH="bcprov-jdk16-137.jar:itext-2.0.4.jar:sign.class:."
      java sign "${CERT}" "${PASSWORD}" "${PDF}" "${PDF_SIGNED}" >/dev/null
      if [ $? == 0 ]
      then
        json "sucesso" "${PDF_SIGNED}" "`eval ${CMD_DATE}`" "${nome}" "${doc}" "PDF Assinado" "${LOCALIZADOR}" "${certDescricao}"
        return 1
      else
        json "falha" "" "`eval ${CMD_DATE}`" "${nome}" "${doc}" "JAVA -> Falha ao assinar o PDF" "${LOCALIZADOR}" ""
        return 0
      fi
      cd -
    else
			echo -e ${pfx_json}
      exit 0
    fi
  else
    json "falha" "${PDF_SIGNED}" "`eval ${CMD_DATE}`" "${nome}" "${doc}" "PDF já foi assinado" "${LOCALIZADOR}" ""
    return 0
  fi
}

## FUNÇÃO: VERIFICAR SE O CERTIFICADO É VÁLIDO
##
## pfx_check /PATH/TO/CERTIFICADO.PFX SENHA LOCALIZADOR
##
## retorna 
##	0 se certificado válido
##	1 se certificado expirado
##	2 se senha incorreta
##	3 se localizador não informado
##	4 se arquivo não for pfx
##
function pfx_check {
  CERT="$1"
  PASSWORD="$2"
  LOCALIZADOR="$3"
  JSON="${OUTPUT_DIR}/${LOCALIZADOR}.json"

  if [ ! -s "${CERT}" ]
  then
    json "falha" "" "`eval ${CMD_DATE}`" "${nome}" "${doc}" "O arquivo nao existe" "${LOCALIZADOR}" ""
    return 0
  fi

  if [[ ! ${CERT: -4} == ".pfx" && ! ${CERT: -4} == ".p12" ]]
  then
    json "falha" "${CERT}" "" "" "" "O arquivo deve ser um PFX ou P12" "${LOCALIZADOR}" ""
    return 4
  fi

  if [ ${#LOCALIZADOR} -eq 0 ]
  then
    json "falha" "${CERT}" "" "" "" "O localizador não foi informado" "localizador_nao_informado" ""
    return 3
  fi

	invalid_password=`openssl pkcs12 -in "${CERT}" -nokeys -legacy -passin pass:"${PASSWORD}" 2>&1 | fgrep -c invalid\ password`

	if [ ${invalid_password} -gt 0 ]
	then
    json "falha" "${CERT}" "" "" "" "Senha do certificado digital incorreta" "${LOCALIZADOR}" ""
		return 2
	fi

  expiration_date=`openssl pkcs12 -in "${CERT}" -nokeys -legacy -passin pass:"${PASSWORD}" | openssl x509 -noout -enddate | cut -d= -f2`
  expiration_date_ts=`date -d "${expiration_date}" +%s`
  current_ts=`date +%s`

  pfx_owner "${CERT}" "${PASSWORD}"

  if [ $((${expiration_date_ts})) -gt $((${current_ts})) ]
  then
    json "sucesso" "${CERT}" "`date -d \"${expiration_date}\" ${FMT_DATE}`" "${nome}" "${doc}" "Certificado Ok" "${LOCALIZADOR}" "${certDescricao}"
    return 0
  else
    json "falha" "${CERT}" "`date -d \"${expiration_date}\" ${FMT_DATE}`" "${nome}" "${doc}" "Certificado expirado" "${LOCALIZADOR}" ""
    return 1
  fi
}

## FUNÇÃO: EXTRAIR O NOME E DOCUMENTO DO CERTIFICADO
##
## pdf_owner CERT PASSWORD
##
## GRAVA AS VARIÁVEIS nome E doc
##
function pfx_owner {
  CERT="$1"
  PASSWORD="$2"

  if [ ! -s "${CERT}" ]
  then
    json "falha" "" "`eval ${CMD_DATE}`" "${nome}" "${doc}" "O arquivo nao existe" "${LOCALIZADOR}" ""
    exit 1
  fi

  if [[ ! ${CERT: -4} == ".pfx" && ! ${CERT: -4} == ".p12" ]]
  then
    echo "O certificado deve ser .pfx ou .p12"
    exit 1
  fi

  CN=`openssl pkcs12 -in "${CERT}" -passin pass:"${PASSWORD}" -clcerts -nokeys -legacy -out - | grep 'CN =' | sed -n 1p`
  CN=`echo ${CN} | sed 's/"//g'`

  nome=`echo ${CN} | sed -E -n 's/.*CN = ([[:print:]]*):([0-9]*).*/\1/p'`
  doc=`echo ${CN} | sed -E -n 's/.*CN = ([[:print:]]*):([0-9]*).*/\2/p'`
  certDescricao=${CN}

}

## FUNÇÃO: VERIFICAR SE O PDF ESTÁ ASSINADO
##
## pdf_check /PATH/TO/ARQUIVO.PDF LOCALIZADOR
##
## retorna 1 se assinatura válida | 0 se a assinatura expirada
##
function pdf_check {
  PDF="$1"
  LOCALIZADOR="$2"
  IS_PDF=`file "${PDF}" | fgrep -c PDF\ document`

  if [ ! -s "${PDF}" ]
  then
    json "falha" "${PDF}" "" "" "" "O arquivo não existe" "${LOCALIZADOR}" ""
    return 0
  fi

  if [ ! "${PDF: -4}" == ".pdf" ] || [ $((${IS_PDF})) -eq 0 ]
  then
    json "falha" "${PDF}" "" "" "" "O arquivo deve ser um PDF" "${LOCALIZADOR}" ""
    return 0
  fi

  NOT_SIGNED=`pdfsig "${PDF}" | fgrep -c "does not contain any signatures"`

  if [ $((${NOT_SIGNED})) -eq 1 ]
  then
    json "falha" "${PDF}" "" "" "" "PDF não assinado" "${LOCALIZADOR}" ""
    return 0
  fi

  VALIDATION=`pdfsig "${PDF}" | grep "Certificate Validation" | cut -d: -f2- | awk '{$1=$1};1'`
  nome=`pdfsig "${PDF}" | grep "Signer Certificate Common Name" | cut -d: -f2 | awk '{$1=$1};1'`
  doc=`pdfsig "${PDF}" | grep "Signer Certificate Common Name" | cut -d: -f3 | awk '{$1=$1};1'`
  DATA_ASSINATURA=`pdfsig "${PDF}" | grep "Signing Time" | cut -d: -f2- | awk '{$1=$1};1'`
  IS_EXPIRED=`echo ${VALIDATION} | fgrep -c "Certificate has Expired"`

  if [ $((${IS_EXPIRED})) -eq 1 ]
  then
    json "falha" "${PDF}" "`date -d \"${DATA_ASSINATURA}\" ${FMT_DATE}`" "${nome}" "${doc}" "Assinatura Expirada" "${LOCALIZADOR}" ""
    return 0
  else
    json "sucesso" "${PDF}" "`date -d \"${DATA_ASSINATURA}\" ${FMT_DATE}`" "${nome}" "${doc}" "Assinatura OK" "${LOCALIZADOR}" ""
    return 1
  fi
}

function json {
  status="$1"
  pathArquivoAssinado="$2"
  dataHoraAssinatura="$3"
  certificadoNome="$4"
  certificadoDocumento="$5"
  erroMensagem="$6"
  localizador="$7"
  certificadoDescricao="$8"
  
  JSON="${OUTPUT_DIR}/${localizador}.json"

	# Obrigatorio uso exclusivo de TABS 
  tee "${JSON}" <<-EOF
	{
		"status": "${status}",
		"pathArquivoAssinado": "${pathArquivoAssinado}",
		"dataHoraAssinatura": "${dataHoraAssinatura}",
    "certificadoDescricao": "${certificadoDescricao}",
		"certificadoDocumento": "${certificadoDocumento}",
		"certificadoNome": "${certificadoNome}",
		"erroMensagem": "${erroMensagem}"
	}
	EOF
}

#######################
## EXECUÇÃO
###################

# Exibir ajuda se não inserir argumentos
if [ "$#" == 0 ] || [ "${1::1}" != "-" ]
then
  help
  exit 0
fi

# Lista de argumentos válidos
while [[ $# -gt 0 ]]; do
  key="$1"
  case "$key" in
    -h|--help)
    help
    shift
    ;;
    -s|--sign)
    [ "$#" != 5 ] && help && exit 0
    pdf_sign "$2" "$3" "$4" "$5" 2>/dev/null
    exit $?
    shift 5
    ;;
    -x|--pfx)
    [ "$#" != 4 ] && help && exit 0
    pfx_check "$2" "$3" "$4" 2>/dev/null
    exit $?
    shift 4
    ;;
    -p|--pdf)
    [ "$#" != 3 ] && help && exit 0
    pdf_check "$2" "$3" 2>/dev/null
    exit $?
    shift 3
    ;;
    *)
    echo "Opção inválida '$key'"
    help
    exit 0
    ;;
  esac
done

exit 0