• Home
• org.gurux
• gurux.dlms
• 4.0.70
• source code
• GXAsn1Converter.java

×

Project download

Many resources are needed to download a project. Please understand that we have to compensate our server costs. Thank you in advance.
Project price only 1 $

You can buy this project and download/modify it how often you want.

gurux.dlms.asn.GXAsn1Converter Maven / Gradle / Ivy

//
// --------------------------------------------------------------------------
//  Gurux Ltd

package gurux.dlms.asn;

import java.io.StringReader;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.security.KeyFactory;
import java.security.NoSuchAlgorithmException;
import java.security.PrivateKey;
import java.security.PublicKey;
import java.security.spec.InvalidKeySpecException;
import java.security.spec.PKCS8EncodedKeySpec;
import java.security.spec.X509EncodedKeySpec;
import java.text.DateFormat;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Calendar;
import java.util.Date;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;
import java.util.TimeZone;

import javax.xml.XMLConstants;
import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;

import org.w3c.dom.DOMException;
import org.w3c.dom.Document;
import org.w3c.dom.Node;
import org.xml.sax.InputSource;

import gurux.dlms.GXByteBuffer;
import gurux.dlms.GXDLMSTranslator;
import gurux.dlms.GXSimpleEntry;
import gurux.dlms.asn.enums.Ecc;
import gurux.dlms.asn.enums.KeyUsage;
import gurux.dlms.asn.enums.PkcsType;
import gurux.dlms.asn.enums.X509Name;
import gurux.dlms.enums.BerType;
import gurux.dlms.internal.GXCommon;
import gurux.dlms.objects.enums.CertificateType;

/*
 * ASN1 converter. This class is used to convert 
 * public and private keys to byte array and vice verse.
 */
public final class GXAsn1Converter {

    /*
     * Constructor.
     */
    private GXAsn1Converter() {

    }

    /**
     * Returns default file path.
     * 
     * @param scheme
     *            Used scheme.
     * @param certificateType
     *            Certificate type.
     * @param systemTitle
     *            System title.
     * @return File path.
     */
    public static Path getFilePath(Ecc scheme, CertificateType certificateType, byte[] systemTitle) {
        Path path;
        switch (certificateType) {
        case DIGITAL_SIGNATURE:
            path = Paths.get("D");
            break;
        case KEY_AGREEMENT:
            path = Paths.get("A");
            break;
        case TLS:
            path = Paths.get("T");
            break;
        default:
            throw new IllegalArgumentException("Unknown certificate type.");
        }
        path = Paths.get(path.toString() + GXDLMSTranslator.toHex(systemTitle, false) + ".pem");
        if (scheme == Ecc.P256) {
            path = Paths.get("Keys", path.toString());
        } else {
            path = Paths.get("Keys384", path.toString());
        }
        return path;
    }

    /**
     * Get private key from bytes.
     * 
     * @param value
     *            Private key bytes.
     * @return Private key.
     * @throws InvalidKeySpecException
     *             Invalid key spec.
     * @throws NoSuchAlgorithmException
     *             No such Algorithm.
     */
    public static PrivateKey getPrivateKey(final byte[] value)
            throws InvalidKeySpecException, NoSuchAlgorithmException {
        if (value != null && (value.length == 32 || value.length == 48)) {
            byte[] privKeyBytes;
            if (value.length == 32) {
                privKeyBytes = GXCommon
                        .hexToBytes("3041020100301306072A8648CE3D0201" + "06082A8648CE3D030107 042730250201010420");
            } else {
                privKeyBytes =
                        GXCommon.hexToBytes("304E020100301006072A8648CE3D0201" + "06052B81040022 043730350201010430");
            }
            byte[] key = new byte[privKeyBytes.length + value.length];
            System.arraycopy(privKeyBytes, 0, key, 0, privKeyBytes.length);
            System.arraycopy(value, 0, key, privKeyBytes.length, value.length);
            PKCS8EncodedKeySpec priv = new PKCS8EncodedKeySpec(key);
            KeyFactory kf = KeyFactory.getInstance("EC");
            return kf.generatePrivate(priv);
        } else {
            throw new IllegalArgumentException("Invalid private key.");
        }
    }

    private static byte[] p256Head = GXCommon.fromBase64("MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE");

    private static byte[] p384Head =
            GXCommon.hexToBytes("30 76 30 10 06 07 2A 86 48 CE 3D 02 01" + "06 05 2B 81 04 00 22 03 62 00 04");

    /**
     * Get public key from bytes.
     * 
     * @param value
     *            Public key bytes.
     * @return Public key.
     */
    public static PublicKey getPublicKey(final byte[] value) {
        if (value != null && (value.length == 64 || value.length == 96)) {
            byte[] head;
            if (value.length == 64) {
                head = p256Head;
            } else {
                head = p384Head;
            }
            byte[] encodedKey;
            encodedKey = new byte[head.length + value.length];
            System.arraycopy(head, 0, encodedKey, 0, head.length);
            System.arraycopy(value, 0, encodedKey, head.length, value.length);
            KeyFactory eckf;
            try {
                eckf = KeyFactory.getInstance("EC");
            } catch (NoSuchAlgorithmException e) {
                throw new IllegalStateException("EC key factory not present in runtime");
            }
            try {
                X509EncodedKeySpec ecpks = new X509EncodedKeySpec(encodedKey);
                return eckf.generatePublic(ecpks);
            } catch (InvalidKeySpecException e) {
                throw new IllegalArgumentException(e.getMessage());
            }

        } else {
            throw new IllegalArgumentException("Invalid public key.");
        }
    }

    /**
     * Convert public key to byte array.
     * 
     * @param key
     *            Public key.
     * @return Public key in byte array.
     */
    public static byte[] rawValue(final PublicKey key) {
        if (key == null) {
            throw new IllegalArgumentException("Invalid public key.");
        }
        GXAsn1BitString tmp =
                (GXAsn1BitString) ((GXAsn1Sequence) GXAsn1Converter.fromByteArray(key.getEncoded())).get(1);
        GXByteBuffer bb = new GXByteBuffer();
        if (key.getEncoded().length == 91) {
            bb.set(tmp.getValue(), 1, 64);
        } else if (key.getEncoded().length == 120) {
            bb.set(tmp.getValue(), 1, 96);
        } else {
            throw new IllegalArgumentException("Invalid public key.");
        }
        return bb.array();
    }

    /**
     * Convert private key to byte array.
     * 
     * @param key
     *            Public key.
     * @return Private key in byte array.
     */
    public static byte[] rawValue(final PrivateKey key) {
        if (key == null) {
            throw new IllegalArgumentException("Invalid private key.");
        }
        byte[] tmp =
                (byte[]) ((GXAsn1Sequence) ((GXAsn1Sequence) GXAsn1Converter.fromByteArray(key.getEncoded())).get(2))
                        .get(1);
        GXByteBuffer bb = new GXByteBuffer();
        bb.set(tmp);
        return bb.array();
    }

    static List> encodeSubject(final String value) {
        X509Name name;
        Object val;
        List> list = new ArrayList>();
        for (String tmp : value.split("[,]")) {
            String[] it = tmp.split("[=]");
            if (it.length != 2) {
                throw new IllegalArgumentException("Invalid subject.");
            }
            name = X509Name.valueOf(it[0].trim());
            switch (name) {
            case C:
                // Country code is printable string
                val = it[1].trim();
                break;
            case E:
                // email address in Verisign certificates
                val = new GXAsn1Ia5String(it[1].trim());
                break;
            default:
                val = new GXAsn1Utf8String(it[1].trim());
            }
            String oid = name.getValue();
            list.add(new GXSimpleEntry(new GXAsn1ObjectIdentifier(oid), val));
        }
        return list;
    }

    public static String getSubject(final GXAsn1Sequence values) {
        Object value;
        StringBuilder sb = new StringBuilder();
        for (Object tmp : values) {
            Map.Entry it = (Map.Entry) tmp;
            sb.append(X509Name.forValue(it.getKey().toString()));
            sb.append('=');
            value = it.getValue();
            sb.append(value);
            sb.append(", ");
        }
        // Remove last comma.
        if (sb.length() != 0) {
            sb.setLength(sb.length() - 2);
        }
        return sb.toString();
    }

    private static void getValue(final GXByteBuffer bb, final List