开放技术领域的 U2 加密

				
openssl command [ command_opts ] [ command_args ] Command
 enc [ options ] - Encryption and Decryption with Ciphers
Discription
The symmetric cipher commands allow data to be encrypted or decrypted 
using various block and stream ciphers using keys based on passwords 
or that are explicitly provided. Base64 encoding or decoding can also be performed 
either by itself or in addition to the encryption or decryption. 
OPTIONS
-in filename 
the input filename, standard input by default. 
-out filename 
the output filename, standard output by default. 
-pass arg 
the password source. For more information about the format of arg, see the 
PASS PHRASE ARGUMENTS section in openssl(1). 
-salt 
use a salt in the key derivation routines. This option should ALWAYS be 
used unless compatibility with previous versions of OpenSSL or SSLeay is 
required. This option is only present on OpenSSL, Versions 0.9.5 or later. 
-nosalt 
do not use a salt in the key derivation routines. This is the default for 
compatibility with previous versions of OpenSSL and SSLeay. 
-e 
encrypt the input data: this is the default. 
-d 
decrypt the input data. 
-a 
base64 process the data. This means that if encryption is taking place, the 
data is base64 encoded after encryption. If decryption is set, the 
input data is base64 decoded before being decrypted. 
-A 
if the -a option is set, base64 process the data on one line. 
-k password 
the password to derive the key from. This is for compatibility with previous 
versions of OpenSSL; superseded by the -pass argument. 
-kfile filename 
read the password to derive the key from the first line of filename. This is 
for compatibility with previous versions of OpenSSL; superseded by the -pass 
argument. 
-S salt 
the actual salt to use: this must be represented as a string comprised only 
of hex digits. 
-K key 
the actual key to use: this must be represented as a string comprised only 
of hex digits. If only the key is specified, the IV must additionally be specified 
using the -iv option. When both a key and a password are specified, the key 
given with the -K option will be used and the IV generated from the password 
will be taken. It probably does not make much sense to specify both key and 
password. 
-iv IV 
the actual IV to use: this must be represented as a string comprised only 
of hex digits. When only the key is specified using the -K option, the IV 
must explicitly be defined. When a password is being specified using one 
of the other options, the IV is generated from this password. 
-p 
print out the key and IV used. 
-P 
print out the key and IV used, then immediately exit: don't do any encryption 
or decryption. 
-bufsize number 
set the buffer size for I/O 
-nopad 
disable standard block padding 
-debug 
debug the BIOs used for I/O. 

				
enc     -       Encryption and Decryption with Ciphers
-nosalt -	       Do not use a salt in the key derivation routines
-iv     -       16 byte intermediate vector 
-rc2    -       Cipher name - 128 bit RC2 in CBC mode
-K      -       Actual 32 byte key in hexadecimal
\       -       Line continuation character
-p      -       Display iv and key
-a      -       Base64 encode after encryption
        -       Base64 decode before decryption
-d      -       Decrypt the input data
-in     -       Input data file 
-out    -       Encoded/encrypted data file
			

				
@echo off
echo Start of Encryption Test
openssl enc -nosalt -iv "4142434445464748" -rc2 -K \ 
"4142434445464748494A4B4C4D4E4F50" -p -a -in instring.asc -out outstring.res
echo Encrypted String: && type outstring.res
echo Decrypted String:
openssl enc -d -nosalt -iv "4142434445464748" -rc2 -K \ 
"4142434445464748494A4B4C4D4E4F50" -a -in outstring.res
echo.

				
My data string         **** NO linefeed at end

				
Start of Encryption Test
key=4142434445464748494A4B4C4D4E4F50
iv =4142434445464748
Encrypted String:
AJnpU8i3/ckdMUqRBarZzw==
Decrypted String:
My data string

				
AJnpU8i3/ckdMUqRBarZzw== 

				
using System;
using System.IO;
using System.Text;
using System.Security.Cryptography;
namespace nikcrypt2
{
   class rc2crypt2
   {
      public static void Main()
      {
         // Input data string
         String instr = "My data string";
         String b64es;
         String decstr;
         byte[] fromEncrypt;
         byte[] encrypted;
         byte[] toEncrypt;
         byte[] es;
         // Create a new 128 bit key.
         byte[] mykey = {0x41,0x42,0x43,0x44,0x45,0x46,0x47,0x48,0x49,0x4A,
         0x4B,0x4C,0x4D,0x4E,0x4F,0x50};
         // Create a new 64 bit initialization vector
         byte[] iv = {0x41,0x42,0x43,0x44,0x45,0x46,0x47,0x48};
         // or to be more readable
         // byte[] mykey = Encoding.ASCII.GetBytes("ABCDEFGHIJKLMNOP");
         // byte[] iv = Encoding.ASCII.GetBytes("ABCDEFGH");
	
         try
         {
            // tick counter
            long StartTickValue = Environment.TickCount;
            Console.WriteLine("Start of Encryption Test\n");
            // 
            ASCIIEncoding textConverter = new ASCIIEncoding();
            // RC2 cryptology
            RC2CryptoServiceProvider rc2Crypto = new RC2CryptoServiceProvider();
            Console.WriteLine("Effective key size is {0} bits.", 
            rc2Crypto.EffectiveKeySize);
            Console.WriteLine("Mode is {0}.", rc2Crypto.Mode);
            // set cypher mode 
            // By default cypher mode CBC is selected ... change CBC to CFB, CTS, ECB, 
            // OFB as needed.
            rc2Crypto.Mode = System.Security.Cryptography.CipherMode.CBC;	
            Console.WriteLine("");
            // Display Key
            String inKey = textConverter.GetString(mykey);
            Console.WriteLine("Input Key:   {0}", inKey);
            // Display IV
            String inIV = textConverter.GetString(iv);
            Console.WriteLine("Input IV:   {0}", inIV);
			
            // Get an encryptor from key and IV.
            ICryptoTransform encryptor = rc2Crypto.CreateEncryptor(mykey, iv);
            // Encrypt the data.
            MemoryStream rc2msEncrypt = new MemoryStream();
            CryptoStream rc2csEncrypt = new CryptoStream(rc2msEncrypt, encryptor, 
            CryptoStreamMode.Write);
            // Convert the data to a byte array.
            toEncrypt = textConverter.GetBytes(instr);
            //Write all data to the crypto stream and flush it.
            rc2csEncrypt.Write(toEncrypt, 0, toEncrypt.Length);
            rc2csEncrypt.FlushFinalBlock();
            //Get encrypted array of bytes.
            encrypted = rc2msEncrypt.ToArray();
            // display encrypted string in base64
            Console.WriteLine("");
            //Convert encrypted to base64
            b64es = Convert.ToBase64String(encrypted);
            Console.WriteLine("Base64 encrypted output : " + (b64es));
            // or
            //Console.WriteLine("Base64 encrypted output : 
            // " + Convert.ToBase64String(encrypted));
								
            // This is where the encrypted data would be transmitted to a recipient
            // who already knows your secret key. Optionally, you ca
            // also encrypt your secret key using a public key algorithm
            // and pass it to the message recipient along with the RC2
            // encrypted message. Base64 conversion of the encrypted string is useful 
            // for transmission using email and so on.
             
            // Get a decryptor that uses the same key and IV as the encryptor.
            ICryptoTransform decryptor = rc2Crypto.CreateDecryptor(mykey, iv);
             
            // Convert base64 encrypted string to encrypted byte array
            es = Convert.FromBase64String(b64es);
             
            // Now decrypt the previously encrypted message using the decryptor
            // obtained in the above step.
            // or decrypt a encrypted base64 string
            MemoryStream rc2msDecrypt = new MemoryStream(es);
            CryptoStream rc2csDecrypt = new CryptoStream(rc2msDecrypt, decryptor, 
            CryptoStreamMode.Read);
            fromEncrypt = new byte[es.Length];
              
            //Read the data out of the crypto stream.
            rc2csDecrypt.Read(fromEncrypt, 0, fromEncrypt.Length);
             
            //Convert the byte array back into a string.
            decstr = textConverter.GetString(fromEncrypt);
              
            //Display the input string (instr) data and the decrypted data.
            Console.WriteLine("");
            Console.WriteLine("Input String:   {0}", instr);
            Console.WriteLine("Decrypted String: {0}", decstr);
            Console.WriteLine("\n");
              
            // tick counter in Milliseconds
            long EndTickValue = Environment.TickCount;
            long FinalTickValue = (EndTickValue - StartTickValue);
              
            // Display elapsed time
            Console.WriteLine("Elapsed Tick count {0}", + FinalTickValue + " ms");
         }
         catch (Exception e)
         {
              Console.WriteLine("Error : " + e);
         }
      }
   }
}

				
Start of Encryption Test
Effective key size is 128 bits.
Mode is CBC.
Input Key:   ABCDEFGHIJKLMNOP
Input IV:   ABCDEFGH
Base64 encrypted output : AJnpU8i3/ckdMUqRBarZzw==
Input String:   My data string
Decrypted String: My data string
Elapsed Tick count 16 ms

				
package sample;
import javax.crypto.*;
import javax.crypto.spec.*;
import sun.misc.*;
/*
 * @author nikk
*/
class rc2crypt2 {
   public static void main(String args[]) {
      String instr = "My data string";
      String b64es;
      String decstr;
      byte[] encrypted;
      byte[] toEncrypt;
      byte[] fromEncrypt;
      byte[] es;
      // Create a new 128 bit key. 
      byte[] mykey = { 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x4a, 
      0x4b, 0x4c, 0x4d, 0x4e, 0x4f, 0x50 };
      // Create a new 64 bit initialization vector
      byte[] iv = { 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48 };
      // or
      // byte[] mykey = "ABCDEFGHIJKLMNOP".getBytes();
      // byte[] iv = "ABCDEFGH".getBytes();
      try {
         // timer counter
         long StartTime = System.currentTimeMillis();
         System.out.println("Start of Encryption Test");
         
         // encrypt
         //  Constructs a secret key from mykey using RC2 algorithm
         SecretKeySpec key = new SecretKeySpec(mykey, "RC2");
         
         // Constructs a parameter set for RC2 from the given effective key size 
         // (in bits) and IV.
         RC2ParameterSpec rc2Spec = new RC2ParameterSpec(128, iv);
			
         // Generates a Cipher object that implements the specified transformation.
         // *** Very time expensive call ***
         // for increase in speed, create object early
         Cipher cipher = Cipher.getInstance("RC2/CBC/PKCS5Padding");
			
         //
         long CipherTime = System.currentTimeMillis();
         long Test1Time = (CipherTime - StartTime);
         System.out.println("Cost of cypher is " + Test1Time + " ms");
			
         // Initializes this cipher with a key and a set of algorithm parameters.
         // *** time expensive call *** 
         cipher.init(Cipher.ENCRYPT_MODE, key, rc2Spec, null);
			
         long initTime = System.currentTimeMillis();
         long Test2Time = (initTime - CipherTime);
         System.out.println("Cost of init is " + Test2Time + " ms");
			
         // Get encrypted array of bytes.
         toEncrypt = instr.getBytes();
			
         // Encrypts  byte data in a single-part operation, or finishes a 
         // multiple-part operation
         encrypted = cipher.doFinal(toEncrypt);
			
         // Get the Key size in bits
         int kbit = rc2Spec.getEffectiveKeyBits();
         System.out.println("Effective key size is " + kbit + " bits.\n");
			
         // get the cipher algorithm
         String alg = cipher.getAlgorithm();
         System.out.println("Algorithm " + alg);
			
         // get the Key
         System.out.println("Input Key : " + new String(key.getEncoded()));
			
         // get the IV
         System.out.println("Input IV : " + new String(cipher.getIV()) + "\n");
			
         // Base 64 Encode the encrypted string
         b64es = new BASE64Encoder().encodeBuffer(encrypted);
         System.out.println("Base64 encrypted output : " + b64es);
			
         // decrypt
         // Convert base64 encrypted string to encrypted byte array 
         es = new BASE64Decoder().decodeBuffer(b64es);
         // Initializes this cipher with a key and a set of algorithm parameters.
         // ** dcipher.init(Cipher.DECRYPT_MODE, key, rc2Spec, null);
         cipher.init(Cipher.DECRYPT_MODE, key, rc2Spec, null);
			
         //decrypt byte array
         // ** fromEncrypt = dcipher.doFinal(es);
         fromEncrypt = cipher.doFinal(es);
			
         // convert byte array into string
         decstr = new String(fromEncrypt);
         System.out.println("Input string : " + instr);
         System.out.println("Output string : " + decstr);
			
         // System.out.println("Output string : " + new String(fromEncrypt));
         long EndTime = System.currentTimeMillis();
         long TotalTime = (EndTime - StartTime);
         System.out.println("Cost of encrypting 8 characters is " + TotalTime + " ms");
      } catch (Exception e) {
         System.out.println("Error : " + e);
      }
   }
}

				
Start of Encryption Test
Cost of cypher is 407 ms
Cost of init is 62 ms
Effective key size is 128 bits.
Algorithm RC2/CBC/PKCS5Padding
Input Key : ABCDEFGHIJKLMNOP
Input IV : ABCDEFGH
Base64 encrypted output : AJnpU8i3/ckdMUqRBarZzw==
Input string : My data string
Output string : My data string
Cost of encrypting 8 characters is 469 ms

				
*
* written by Nik Kesic
*
A=protocolLogging("rc2crypt.log", "ON", "10")   ; * Turn on logging
result=""
ALGORITHM="rc2-cbc"	                        ; * 128 bit rc2 algorithm in CBC mode
MYKEY="4142434445464748494A4B4C4D4E4F50"	               ; * HEX - Actual Key
IV="4142434445464748"	                        ; * HEX - Initialization Vector
INSTR="My data string"	                        ; * Data String
DATALOC=1                           		; * Data in String
KEYLOC=1	                          	; * Key in String
ACTION=2	                           	; * Base64 encode after encryption
KEYACTION=3                              	; * KEY_ACTUAL_OPENSSL
SALT=""	                                        ; * SALT not used
RESULTLOC=1                              	; * Result in String RESULT
PRINT "Start of Encryption Test"
CRT
PRINT "Effective key size is 128 bits."
PRINT "Algorithm ":ALGORITHM
PRINT "Input Key : ":MYKEY
PRINT "Input IV : ":IV
*
* Call to ENCRYPT function - 0 = good response
*
RETURN.CODE=ENCRYPT(ALGORITHM,ACTION,INSTR,DATALOC,MYKEY,KEYLOC,KEYACTION,SALT,IV,
RESULT,RESULTLOC)
IF RETURN.CODE <> 0 THEN 
  CRT "Error in Encrypt : "
  STOP
END 
CRT
PRINT "Base64 encrypted output : ":RESULT
*
ACTION="4"                        		; * Base64 decode before encryption
CRT "Input String : ":INSTR
*
* Call to DECRYPT function - 0 = good response\
*
RETURN.CODE=ENCRYPT(ALGORITHM,ACTION,RESULT,DATALOC,MYKEY,KEYLOC,KEYACTION,SALT,IV,
DECRESULT,RESULTLOC)
IF RETURN.CODE <> 0 THEN 
  CRT "Error in Decrypt : "
  STOP
END
CRT "Decrypted String : ":DECRESULT         	; * Output of decrypted string
FinalTime=SYSTEM(9)               ; * Time program ran in milliseconds
PRINT "Cost of encrypting 8 characters is ":FinalTime:" ms"
A=protocolLogging("", "OFF", "")         	; * Turn on logging
END

				
Start of Encryption Test
Effective key size is 128 bits.
Algorithm rc2-cbc
Input Key : 4142434445464748494A4B4C4D4E4F50
Input IV : 4142434445464748
Base64 encrypted output : AJnpU8i3/ckdMUqRBarZzw==
Input String : My data string
Decrypted String : My data string
Cost of encrypting 8 characters is 10 ms

				
*
* written by Nik Kesic
* workaround for OPENSSL compatible encrypt until issue 8088 is resolved
*
IV="4142434445464748"
MYKEY="4142434445464748494A4B4C4D4E4F50"
ALGORITHM=" -rc2"
INSTR="My data string"
PRINT "Start of Encryption Test"
CRT
PRINT "Effective key size is 128 bits."
PRINT "Algorithm ":ALGORITHM
PRINT "Input Key : ":MYKEY
PRINT "Input IV : ":IV
*
comm="echo ":INSTR:"|openssl enc -nosalt -iv ":IV:ALGORITHM:" 
-K ":MYKEY:" -a -out mydata.enc"
* PRINT comm
*
PCPERFORM "type mydata.enc" CAPTURING RESULT
CRT
PRINT "Base64 encrypted output : ":RESULT
PCPERFORM comm
*
* Universe
* EXECUTE comm
*
CRT "Input String : ":INSTR
dcomm="openssl enc -d -nosalt -iv ":IV:ALGORITHM:" -K ":MYKEY:" -a -in mydata.enc"
PCPERFORM dcomm CAPTURING DECRESULT
CRT "Decrypted String : ":DECRESULT
FinalTime=SYSTEM(9)                  ; * Time program ran in milli seconds
PRINT "Cost of encrypting 8 characters is ":FinalTime:" ms"
END

				
Start of Encryption Test
Effective key size is 128 bits.
Algorithm  -rc2
Input Key : 4142434445464748494A4B4C4D4E4F50
Input IV : 4142434445464748
Base64 encrypted output : AJnpU8i3/cml4YH2PsT2k4tspzJ5i9hC
Input String : My data string
Decrypted String : My data string
Cost of encrypting 8 characters is 26 ms