virgil-crypto 2.0.2b0

data/ext/native/src/lib/include/virgil/crypto/foundation/asn1/VirgilAsn1Compatible.h

@@ -0,0 +1,100 @@
+/**
+ * Copyright (C) 2015-2016 Virgil Security Inc.
+ *
+ * Lead Maintainer: Virgil Security Inc. <support@virgilsecurity.com>
+ *
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *
+ *     (1) Redistributions of source code must retain the above copyright
+ *     notice, this list of conditions and the following disclaimer.
+ *
+ *     (2) Redistributions in binary form must reproduce the above copyright
+ *     notice, this list of conditions and the following disclaimer in
+ *     the documentation and/or other materials provided with the
+ *     distribution.
+ *
+ *     (3) Neither the name of the copyright holder nor the names of its
+ *     contributors may be used to endorse or promote products derived from
+ *     this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ''AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT,
+ * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
+ * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
+ * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef VIRGIL_CRYPTO_VIRGIL_ASN1_COMPATIBLE_H
+#define VIRGIL_CRYPTO_VIRGIL_ASN1_COMPATIBLE_H
+
+#include <virgil/crypto/VirgilByteArray.h>
+
+/**
+ * @name Forward declaration
+ */
+/// @{
+namespace virgil { namespace crypto { namespace foundation { namespace asn1 {
+class VirgilAsn1Reader;
+
+class VirgilAsn1Writer;
+}}}}
+/// @}
+
+
+namespace virgil { namespace crypto { namespace foundation { namespace asn1 {
+
+/**
+ * @brief This class provides interface that allow to save and restore object state in the ASN.1 structure.
+ */
+class VirgilAsn1Compatible {
+public:
+    /**
+     * @brief Save object state to the ASN.1 structure.
+     */
+    virgil::crypto::VirgilByteArray toAsn1() const;
+
+    /**
+     * @brief Restore object state from the ASN.1 structure.
+     */
+    void fromAsn1(const virgil::crypto::VirgilByteArray& asn1);
+
+    /**
+     * @brief Polymorphic destructor.
+     */
+    virtual ~VirgilAsn1Compatible() noexcept { }
+
+    /**
+     * @brief Write object state to the writer.
+     * @param asn1Writer writer that should be payloaded by subclasses.
+     * @param childWrittenBytes count of bytes that was written by subclasses.
+     * @return Writen bytes count.
+     */
+    virtual size_t asn1Write(VirgilAsn1Writer& asn1Writer, size_t childWrittenBytes = 0) const = 0;
+
+    /**
+     * @brief Read object state from the reader.
+     * @param asn1Reader reader payloaded with ASN.1 to be read.
+     */
+    virtual void asn1Read(VirgilAsn1Reader& asn1Reader) = 0;
+
+protected:
+    /**
+     * @brief If given parameter is empty exception will be thrown.
+     * @throw virgil::crypto::VirgilCryptoException.
+     */
+    virtual void checkRequiredField(const VirgilByteArray& param) const;
+};
+
+}}}}
+
+#endif /* VIRGIL_CRYPTO_VIRGIL_ASN1_COMPATIBLE_H */

data/ext/native/src/lib/include/virgil/crypto/foundation/asn1/VirgilAsn1Reader.h

@@ -0,0 +1,179 @@
+/**
+ * Copyright (C) 2015-2016 Virgil Security Inc.
+ *
+ * Lead Maintainer: Virgil Security Inc. <support@virgilsecurity.com>
+ *
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *
+ *     (1) Redistributions of source code must retain the above copyright
+ *     notice, this list of conditions and the following disclaimer.
+ *
+ *     (2) Redistributions in binary form must reproduce the above copyright
+ *     notice, this list of conditions and the following disclaimer in
+ *     the documentation and/or other materials provided with the
+ *     distribution.
+ *
+ *     (3) Neither the name of the copyright holder nor the names of its
+ *     contributors may be used to endorse or promote products derived from
+ *     this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ''AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT,
+ * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
+ * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
+ * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef VIRGIL_CRYPTO_VIRGIL_ASN1_READER_H
+#define VIRGIL_CRYPTO_VIRGIL_ASN1_READER_H
+
+#include <cstdlib>
+#include <string>
+
+#include <virgil/crypto/VirgilByteArray.h>
+
+namespace virgil { namespace crypto { namespace foundation { namespace asn1 {
+
+/**
+ * @brief This class provides methods for reading ASN.1 data structure.
+ *
+ * @note All "read*" methods perform reading of ASN.1 structure sequentially.
+ * @note Implementation is not complete yet, only minimum set of operations are supported.
+ */
+class VirgilAsn1Reader {
+public:
+    /**
+     * @brief Initialize internal state.
+     */
+    VirgilAsn1Reader();
+
+    /**
+     * @brief Initialize internal state with given ASN.1 structure.
+     * @note The same as sequence VirgilAsn1Reader() and reset().
+     */
+    explicit VirgilAsn1Reader(const virgil::crypto::VirgilByteArray& data);
+
+    /**
+     * @brief Dispose internal resources.
+     */
+    ~VirgilAsn1Reader() noexcept;
+    /**
+     * @name Configure reading
+     */
+    ///@{
+    /**
+     * @brief Reset all internal states and prepare to new ASN.1 reading operations.
+     * @param data - ASN.1 structure to be read.
+     */
+    void reset(const virgil::crypto::VirgilByteArray& data);
+    ///@}
+    /**
+     * @name Read Simple ASN.1 Types
+     */
+    ///@{
+    /**
+     * @brief Read ASN.1 type: INTEGER.
+     */
+    int readInteger();
+
+    /**
+     * @brief Read ASN.1 type: BOOLEAN.
+     */
+    bool readBool();
+
+    /**
+     * @brief Read ASN.1 type: NULL.
+     */
+    void readNull();
+
+    /**
+     * @brief Read ASN.1 type: OCTET STRING.
+     */
+    virgil::crypto::VirgilByteArray readOctetString();
+
+    /**
+     * @brief Read ASN.1 type: UTF8String.
+     */
+    virgil::crypto::VirgilByteArray readUTF8String();
+
+    /**
+     * @brief Read preformatted ASN.1 structure.
+     */
+    virgil::crypto::VirgilByteArray readData();
+
+    /**
+     * @brief Read ASN.1 type: TAG.
+     * @return Tag length if given tag exist, 0 - otherwise.
+     */
+    size_t readContextTag(unsigned char tag);
+
+    /**
+     * @brief Read ASN.1 type: OID.
+     * @return OID.
+     * TODO: Change return type to VirgilByteArray
+     */
+    std::string readOID();
+    ///@}
+    /**
+     * @name Read Structured ASN.1 Types
+     */
+    ///@{
+    /**
+     * @brief Read ASN.1 type: SEQUENCE.
+     * @return Sequence size in bytes.
+     */
+    size_t readSequence();
+
+    /**
+     * @brief Read ASN.1 type: SET.
+     * @return Set size in bytes.
+     */
+    size_t readSet();
+    ///@}
+public:
+    /**
+     * @brief Delete copy constructor
+     */
+    VirgilAsn1Reader(const VirgilAsn1Reader& other) = delete;
+
+    /**
+     * @brief Delete assignment operator
+     */
+    VirgilAsn1Reader& operator=(const VirgilAsn1Reader& rhs) = delete;
+
+    /**
+     * @brief Use default move constructor
+     */
+    VirgilAsn1Reader(VirgilAsn1Reader&& other) = default;
+
+    /**
+     * @brief Use default move operator
+     */
+    VirgilAsn1Reader& operator=(VirgilAsn1Reader&& rhs) = default;
+
+private:
+    /**
+     * @brief Check internal state before methods call.
+     * @throw VirgilCryptoException - if internal state is not consistent.
+     */
+    void checkState();
+
+private:
+    unsigned char* p_;
+    const unsigned char* end_;
+    virgil::crypto::VirgilByteArray data_;
+};
+
+}}}}
+
+#endif /* VIRGIL_CRYPTO_VIRGIL_ASN1_READER_H */

data/ext/native/src/lib/include/virgil/crypto/foundation/asn1/VirgilAsn1Writer.h

@@ -0,0 +1,241 @@
+/**
+ * Copyright (C) 2015-2016 Virgil Security Inc.
+ *
+ * Lead Maintainer: Virgil Security Inc. <support@virgilsecurity.com>
+ *
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *
+ *     (1) Redistributions of source code must retain the above copyright
+ *     notice, this list of conditions and the following disclaimer.
+ *
+ *     (2) Redistributions in binary form must reproduce the above copyright
+ *     notice, this list of conditions and the following disclaimer in
+ *     the documentation and/or other materials provided with the
+ *     distribution.
+ *
+ *     (3) Neither the name of the copyright holder nor the names of its
+ *     contributors may be used to endorse or promote products derived from
+ *     this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ''AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT,
+ * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
+ * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
+ * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef VIRGIL_CRYPTO_VIRGIL_ASN1_WRITER_H
+#define VIRGIL_CRYPTO_VIRGIL_ASN1_WRITER_H
+
+#include <cstdlib>
+#include <string>
+#include <vector>
+
+#include <virgil/crypto/VirgilByteArray.h>
+
+namespace virgil { namespace crypto { namespace foundation { namespace asn1 {
+
+/**
+ * @brief This class provides methods for writing ASN.1 data structure.
+ *
+ * @note All "write*" methods perform writing of ASN.1 structure sequentially.
+ * @note Implementation is not complete yet, only minimum set of operations are supported.
+ */
+class VirgilAsn1Writer {
+public:
+    /**
+     * @brief Initialize internal state for the first use.
+     * @see @link reset @endlink method for reusing this class to create new ASN.1 stucture.
+     */
+    VirgilAsn1Writer();
+
+    /**
+     * @brief Initialize internal state for the first use.
+     * @param capacity - expected ASN.1 final size
+     * @see @link reset @endlink method for reusing this class to create new ASN.1 stucture.
+     */
+    VirgilAsn1Writer(size_t capacity);
+
+    /**
+     * @brief Dispose internal resources.
+     */
+    ~VirgilAsn1Writer() noexcept;
+    /**
+     * @name Start and Finish writing
+     */
+    ///@{
+    /**
+     * @brief Reset all internal states and prepare to new ASN.1 writing operations.
+     */
+    void reset();
+
+    /**
+     * @brief Reset all internal states and prepare to new ASN.1 writing operations.
+     * @param capacity - expected ASN.1 final size
+     */
+    void reset(size_t capacity);
+
+    /**
+     * @brief Returns the result ASN.1 structure.
+     * @return ASN.1 structure that was written.
+     * @warning After call this method all attempts to write more data will cause exceptions.
+     */
+    virgil::crypto::VirgilByteArray finish();
+    ///@}
+    /**
+     * @name Write Simple ASN.1 Types
+     */
+    ///@{
+    /**
+     * @brief Write ASN.1 type: INTEGER.
+     * @param value - integer value to be written.
+     * @return Written bytes.
+     */
+    size_t writeInteger(int value);
+
+    /**
+     * @brief Write ASN.1 type: BOOLEAN.
+     * @param value - boolean value to be written.
+     * @return Written bytes.
+     */
+    size_t writeBool(bool value);
+
+    /**
+     * @brief Write ASN.1 type: NULL.
+     * @return Written bytes.
+     */
+    size_t writeNull();
+
+    /**
+     * @brief Write ASN.1 type: OCTET STRING.
+     * @param data - octet string to be written.
+     * @return Written bytes.
+     */
+    size_t writeOctetString(const virgil::crypto::VirgilByteArray& data);
+
+    /**
+     * @brief Write ASN.1 type: UTF8String.
+     * @param data - UTF8 string to be written.
+     * @return Written bytes.
+     */
+    size_t writeUTF8String(const virgil::crypto::VirgilByteArray& data);
+
+    /**
+     * @brief Write ASN.1 type: TAG.
+     * @param tag - custom tag.
+     * @param len - length of the taged element, use methods return value to calculate it.
+     * @return Written bytes.
+     */
+    size_t writeContextTag(unsigned char tag, size_t len);
+
+    /**
+     * @brief Write preformatted ASN.1 structure.
+     * @param data - ASN.1 structure.
+     * @return Written bytes.
+     */
+    size_t writeData(const virgil::crypto::VirgilByteArray& data);
+
+    /**
+     * @brief Write ASN.1 type: OID.
+     * @param oid - the OID to write.
+     * @return Written bytes.
+     */
+    size_t writeOID(const std::string& oid);
+    ///@}
+    /**
+     * @name Write Structured ASN.1 Types
+     */
+    ///@{
+    /**
+     * @brief Write ASN.1 type: SEQUENCE.
+     * @param len - sequence length in bytes.
+     * @return Written bytes.
+     */
+    size_t writeSequence(size_t len);
+
+    /**
+     * @brief Write ASN.1 type: SET OF ANY.
+     * @param set - set of any data represented as byte sequence.
+     * @return Written bytes.
+     */
+    size_t writeSet(const std::vector<virgil::crypto::VirgilByteArray>& set);
+    ///@}
+private:
+    /**
+     * @brief Logically pad the shorter DER encoding after the last octet with dummy octets,
+     *     that are smaller in value than any normal octet.
+     * @param asn1 - ASN.1 structure that will be padded.
+     * @param finalSize - ASN.1 structure size after padding.
+     */
+    static virgil::crypto::VirgilByteArray
+            makeComparePadding(const virgil::crypto::VirgilByteArray& asn1, size_t finalSize);
+
+    /**
+     * @brief Perform lexicographic ASN.1 comparison.
+     */
+    static bool compare(const virgil::crypto::VirgilByteArray& first, const virgil::crypto::VirgilByteArray& second);
+
+    /**
+     * @brief Perform ascending lexicographic order on the given set.
+     */
+    static void makeOrderedSet(std::vector<virgil::crypto::VirgilByteArray>& set);
+
+public:
+    /**
+     * @brief Use default move constructor
+     */
+    VirgilAsn1Writer(VirgilAsn1Writer&& other) = default;
+
+    /**
+     * @brief Use default move operator
+     */
+    VirgilAsn1Writer& operator=(VirgilAsn1Writer&& rhs) = default;
+
+
+private:
+    /**
+     * @brief Check internal state before methods call.
+     * @throw VirgilCryptoException - if internal state is not consistent.
+     */
+    void checkState();
+
+    /**
+     * @brief Dispose internal resources.
+     */
+    void dispose() noexcept;
+
+    /**
+     * @brief Reserve additional space for ASN.1 buffer.
+     * @param newBufLen - new ASN.1 buffer size in bytes.
+     * @note newBufLen MUST be greate than current ASN.1 buffer length.
+     */
+    void relocateBuffer(size_t newBufLen);
+
+    /**
+     * @brief Ensures that ASN.1 buffer length enough to be able write data of the given length.
+     *
+     * If ASN.1 buffer left capacity is not enough to be able write data of the given length,
+     *     buffer will be relocated with more capacity.
+     */
+    void ensureBufferEnough(size_t len);
+
+private:
+    unsigned char* p_;
+    unsigned char* start_;
+    unsigned char* buf_;
+    size_t bufLen_;
+};
+
+}}}}
+
+#endif /* VIRGIL_CRYPTO_VIRGIL_ASN1_WRITER_H */