예제 #1
0
        /// <summary>Decodes the given Radix64-encoded String
        /// to a byte array that is filled with the decoded binary
        /// data.<br></br>
        /// The parameter strData has to have a checksum appended.
        /// This checksum is also verified.
        /// </summary>
        /// <exception cref="ApplicationException">
        /// An ApplicationException is thrown when the parameter strData
        /// did not have a checksum appended, or if the checksum was
        /// incorrect.
        /// </exception>
        /// <param name="strData">Radix64 encoded String</param>
        /// <returns>Returns a byte array containing the decoded
        /// base64 data.</returns>
        /// <remarks>No remarks</remarks>
        public static byte[] Decode(string strData)
        {
            //Get the checksum of the message
            int    nChecksumstart = strData.LastIndexOf('=');
            string strCRC         = "";

            try {
                strCRC = strData.Substring(nChecksumstart + 1, 4);
            } catch {
                throw new System.ApplicationException("The Radix64 checksum was wrong!");
            }

            //Strip the checksum from the real message
            strData = strData.Substring(0, nChecksumstart);

            byte[] bData = Convert.FromBase64String(strData);

            string strShouldCRC = Radix64.CRC_Checksum(bData).Trim();

            if (strShouldCRC != strCRC)
            {
                throw new System.ApplicationException("The Radix64 checksum was wrong!");
            }
            return(bData);
        }
예제 #2
0
        /// <summary>
        /// Armors an OpenPGP Cleartextsignature.
        /// </summary>
        /// <param name="strMessage">The Message that has been signed. Note that it
        /// must not be Dash Escaped before handing it to this function.</param>
        /// <param name="strSignature">The OpenPGP signature of the given
        /// message formated in Radix64.</param>
        /// <returns>The armored OpenPGP cleartext signature.</returns>
        public static string WrapCleartextSignature(string strMessage, string strSignature)
        {
            string strFinal = "-----BEGIN PGP SIGNED MESSAGE-----\r\n";

            strFinal += "Hash: SHA1\r\n\r\n";
            strFinal += Radix64.DashEscape(strMessage);
            strFinal += "\r\n-----BEGIN PGP SIGNATURE-----\r\n";
            strFinal += "Version: " + SharpPrivacyLibrary.ApplicationVersionInfos + "\r\n\r\n";
            strFinal += strSignature;
            strFinal += "-----END PGP SIGNATURE-----\r\n";

            return(strFinal);
        }
예제 #3
0
        private static string CRC_Checksum(byte[] bData)
        {
            long crc = 0xb704ce;

            byte[] bCRC = new byte[3];

            for (int i = 0; i < bData.Length; i++)
            {
                crc = (crc << 8) ^ CRCTable[((crc >> 16) ^ bData[i]) & 0xff];
            }

            crc &= 0xffffff;

            bCRC[0] = (byte)((crc & 0xFF0000) >> 16);
            bCRC[1] = (byte)((crc & 0x00FF00) >> 8);
            bCRC[2] = (byte)((crc & 0x0000FF));

            return(Radix64.Encode(bCRC, false));
        }
예제 #4
0
 /// <summary>
 /// Armors an OpenPGP Cleartextsignature.
 /// </summary>
 /// <param name="strMessage">The Message that has been signed. Note that it
 /// must not be Dash Escaped before handing it to this function.</param>
 /// <param name="bSignature">The OpenPGP signature of the given
 /// message formated in binary.</param>
 /// <returns>The armored OpenPGP cleartext signature.</returns>
 public static string WrapCleatextSignature(string strMessage, byte[] bSignature)
 {
     return(WrapCleartextSignature(strMessage, Radix64.Encode(bSignature, true)));
 }
예제 #5
0
 /// <summary>
 /// Armors a binary formated OpenPGP message.
 /// </summary>
 /// <param name="bKey">The OpenPGP message in binary form.</param>
 /// <returns>Returns the armored OpenPGP message.</returns>
 public static string WrapMessage(byte[] bMessage)
 {
     return(WrapMessage(Radix64.Encode(bMessage, true)));
 }
예제 #6
0
 /// <summary>
 /// Armors an OpenPGP encoded public key.
 /// </summary>
 /// <param name="bKey">The public key encoded in OpenPGP format.</param>
 /// <returns>Returns the armored public key.</returns>
 public static string WrapPublicKey(byte[] bKey)
 {
     return(WrapPublicKey(Radix64.Encode(bKey, true)));
 }
예제 #7
0
        /// <summary>
        /// Static function that makes parsing packets easy. Just give
        /// a Radix64 encoded representation of a set of OpenPGP packets
        /// as parameter, and the function returns an array of packets
        /// that are the parsed OpenPGP packets.
        /// </summary>
        /// <param name="strBase64Text">A string containing the Radix64
        /// representation of a set of OpenPGP packets</param>
        /// <returns>Returns an array of packets</returns>
        /// <remarks>No remarks</remarks>
        public static Packet[] ParsePackets(string strBase64Text)
        {
            byte[] bData = Radix64.Decode(strBase64Text);

            return(ParsePackets(bData));
        }