PHP加密解密:
- class JoDES {
- private static $_instance = NULL;
- /**
- * @return JoDES
- */
- public static function share() {
- if (is_null(self::$_instance)) {
- self::$_instance = new JoDES();
- }
- return self::$_instance;
- }
- /**
- * 加密
- * @param string $str 要处理的字符串
- * @param string $key 加密Key,为8个字节长度
- * @return string
- */
- public function encode($str, $key) {
- $size = mcrypt_get_block_size(MCRYPT_DES, MCRYPT_MODE_CBC);
- $str = $this->pkcs5Pad($str, $size);
- $aaa = mcrypt_cbc(MCRYPT_DES, $key, $str, MCRYPT_ENCRYPT, $key);
- $ret = base64_encode($aaa);
- return $ret;
- }
- /**
- * 解密
- * @param string $str 要处理的字符串
- * @param string $key 解密Key,为8个字节长度
- * @return string
- */
- public function decode($str, $key) {
- $strBin = base64_decode($str);
- $str = mcrypt_cbc(MCRYPT_DES, $key, $strBin, MCRYPT_DECRYPT, $key);
- $str = $this->pkcs5Unpad($str);
- return $str;
- }
- function hex2bin($hexData) {
- $binData = "";
- for ($i = 0; $i < strlen($hexData); $i += 2) {
- $binData .= chr(hexdec(substr($hexData, $i, 2)));
- }
- return $binData;
- }
- function pkcs5Pad($text, $blocksize) {
- $pad = $blocksize - (strlen($text) % $blocksize);
- return $text . str_repeat(chr($pad), $pad);
- }
- function pkcs5Unpad($text) {
- $pad = ord($text {strlen($text) - 1});
- if ($pad > strlen($text))
- return false;
- if (strspn($text, chr($pad), strlen($text) - $pad) != $pad)
- return false;
- return substr($text, 0, - 1 * $pad);
- }
- }
C#加密解密:
- public class MyDes
- {
- /// <summary>
- /// DES加密方法
- /// </summary>
- /// <param name="strPlain">明文</param>
- /// <param name="strDESKey">密钥</param>
- /// <param name="strDESIV">向量</param>
- /// <returns>密文</returns>
- public static string Encode(string source, string _DESKey)
- {
- StringBuilder sb = new StringBuilder();
- using (DESCryptoServiceProvider des = new DESCryptoServiceProvider())
- {
- byte[] key = ASCIIEncoding.ASCII.GetBytes(_DESKey);
- byte[] iv = ASCIIEncoding.ASCII.GetBytes(_DESKey);
- byte[] dataByteArray = Encoding.UTF8.GetBytes(source);
- des.Mode = System.Security.Cryptography.CipherMode.CBC;
- des.Key = key;
- des.IV = iv;
- string encrypt = "";
- using (MemoryStream ms = new MemoryStream())
- using (CryptoStream cs = new CryptoStream(ms, des.CreateEncryptor(), CryptoStreamMode.Write))
- {
- cs.Write(dataByteArray, 0, dataByteArray.Length);
- cs.FlushFinalBlock();
- encrypt = Convert.ToBase64String(ms.ToArray());
- }
- return encrypt;
- }
- }
- /// <summary>
- /// 进行DES解密。
- /// </summary>
- /// <param name="pToDecrypt">要解密的base64串</param>
- /// <param name="sKey">密钥,且必须为8位。</param>
- /// <returns>已解密的字符串。</returns>
- public static string Decode(string source, string sKey)
- {
- byte[] inputByteArray = System.Convert.FromBase64String(source);
- //Encoding.UTF8.GetBytes(source);
- using (DESCryptoServiceProvider des = new DESCryptoServiceProvider())
- {
- des.Key = ASCIIEncoding.ASCII.GetBytes(sKey);
- des.IV = ASCIIEncoding.ASCII.GetBytes(sKey);
- System.IO.MemoryStream ms = new System.IO.MemoryStream();
- using (CryptoStream cs = new CryptoStream(ms, des.CreateDecryptor(), CryptoStreamMode.Write))
- {
- cs.Write(inputByteArray, 0, inputByteArray.Length);
- cs.FlushFinalBlock();
- cs.Close();
- }
- string str = Encoding.UTF8.GetString(ms.ToArray());
- ms.Close();
- return str;
- }
- }
JAVA & Android:
- package com.example.aric.test;
- import javax.crypto.Cipher;
- import javax.crypto.SecretKey;
- import javax.crypto.SecretKeyFactory;
- import javax.crypto.spec.DESKeySpec;
- import javax.crypto.spec.IvParameterSpec;
- import android.util.Base64;
- public class DES {
- public final static String DES_KEY_STRING = "ABSujsuu";
- public static String encrypt(String message, String key) throws Exception {
- Cipher cipher = Cipher.getInstance("DES/CBC/PKCS5Padding");
- DESKeySpec desKeySpec = new DESKeySpec(key.getBytes("UTF-8"));
- SecretKeyFactory keyFactory = SecretKeyFactory.getInstance("DES");
- SecretKey secretKey = keyFactory.generateSecret(desKeySpec);
- IvParameterSpec iv = new IvParameterSpec(key.getBytes("UTF-8"));
- cipher.init(Cipher.ENCRYPT_MODE, secretKey, iv);
- return encodeBase64(cipher.doFinal(message.getBytes("UTF-8")));
- }
- public static String decrypt(String message, String key) throws Exception {
- byte[] bytesrc = decodeBase64(message);//convertHexString(message);
- Cipher cipher = Cipher.getInstance("DES/CBC/PKCS5Padding");
- DESKeySpec desKeySpec = new DESKeySpec(key.getBytes("UTF-8"));
- SecretKeyFactory keyFactory = SecretKeyFactory.getInstance("DES");
- SecretKey secretKey = keyFactory.generateSecret(desKeySpec);
- IvParameterSpec iv = new IvParameterSpec(key.getBytes("UTF-8"));
- cipher.init(Cipher.DECRYPT_MODE, secretKey, iv);
- byte[] retByte = cipher.doFinal(bytesrc);
- return new String(retByte);
- }
- public static byte[] convertHexString(String ss) {
- byte digest[] = new byte[ss.length() / 2];
- for (int i = 0; i < digest.length; i++) {
- String byteString = ss.substring(2 * i, 2 * i + 2);
- int byteValue = Integer.parseInt(byteString, 16);
- digest[i] = (byte) byteValue;
- }
- return digest;
- }
- public static String toHexString(byte b[]) {
- StringBuffer hexString = new StringBuffer();
- for (int i = 0; i < b.length; i++) {
- String plainText = Integer.toHexString(0xff & b[i]);
- if (plainText.length() < 2)
- plainText = "0" + plainText;
- hexString.append(plainText);
- }
- return hexString.toString();
- }
- public static String encodeBase64(byte[] b) {
- return Base64.encodeToString(b, Base64.DEFAULT);
- }
- public static byte[] decodeBase64(String base64String) {
- return Base64.decode(base64String, Base64.DEFAULT);
- }
- }
java所需Base64类:
- /*
- * Copyright (C) 2010 The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
- package com.myfund.cxf.utils;
- import java.io.UnsupportedEncodingException;
- /**
- * Utilities for encoding and decoding the Base64 representation of
- * binary data. See RFCs <a
- * href="http://www.ietf.org/rfc/rfc2045.txt">2045</a> and <a
- * href="http://www.ietf.org/rfc/rfc3548.txt">3548</a>.
- */
- public class Base64 {
- /**
- * Default values for encoder/decoder flags.
- */
- public static final int DEFAULT = 0;
- /**
- * Encoder flag bit to omit the padding '=' characters at the end
- * of the output (if any).
- */
- public static final int NO_PADDING = 1;
- /**
- * Encoder flag bit to omit all line terminators (i.e., the output
- * will be on one long line).
- */
- public static final int NO_WRAP = 2;
- /**
- * Encoder flag bit to indicate lines should be terminated with a
- * CRLF pair instead of just an LF. Has no effect if {@code
- * NO_WRAP} is specified as well.
- */
- public static final int CRLF = 4;
- /**
- * Encoder/decoder flag bit to indicate using the "URL and
- * filename safe" variant of Base64 (see RFC 3548 section 4) where
- * {@code -} and {@code _} are used in place of {@code +} and
- * {@code /}.
- */
- public static final int URL_SAFE = 8;
- /**
- * Flag to pass to {@link Base64OutputStream} to indicate that it
- * should not close the output stream it is wrapping when it
- * itself is closed.
- */
- public static final int NO_CLOSE = 16;
- // --------------------------------------------------------
- // shared code
- // --------------------------------------------------------
- /* package */ static abstract class Coder {
- public byte[] output;
- public int op;
- /**
- * Encode/decode another block of input data. this.output is
- * provided by the caller, and must be big enough to hold all
- * the coded data. On exit, this.opwill be set to the length
- * of the coded data.
- *
- * @param finish true if this is the final call to process for
- * this object. Will finalize the coder state and
- * include any final bytes in the output.
- *
- * @return true if the input so far is good; false if some
- * error has been detected in the input stream..
- */
- public abstract boolean process(byte[] input, int offset, int len, boolean finish);
- /**
- * @return the maximum number of bytes a call to process()
- * could produce for the given number of input bytes. This may
- * be an overestimate.
- */
- public abstract int maxOutputSize(int len);
- }
- // --------------------------------------------------------
- // decoding
- // --------------------------------------------------------
- /**
- * Decode the Base64-encoded data in input and return the data in
- * a new byte array.
- *
- * <p>The padding '=' characters at the end are considered optional, but
- * if any are present, there must be the correct number of them.
- *
- * @param str the input String to decode, which is converted to
- * bytes using the default charset
- * @param flags controls certain features of the decoded output.
- * Pass {@code DEFAULT} to decode standard Base64.
- *
- * @throws IllegalArgumentException if the input contains
- * incorrect padding
- */
- public static byte[] decode(String str, int flags) {
- return decode(str.getBytes(), flags);
- }
- /**
- * Decode the Base64-encoded data in input and return the data in
- * a new byte array.
- *
- * <p>The padding '=' characters at the end are considered optional, but
- * if any are present, there must be the correct number of them.
- *
- * @param input the input array to decode
- * @param flags controls certain features of the decoded output.
- * Pass {@code DEFAULT} to decode standard Base64.
- *
- * @throws IllegalArgumentException if the input contains
- * incorrect padding
- */
- public static byte[] decode(byte[] input, int flags) {
- return decode(input, 0, input.length, flags);
- }
- /**
- * Decode the Base64-encoded data in input and return the data in
- * a new byte array.
- *
- * <p>The padding '=' characters at the end are considered optional, but
- * if any are present, there must be the correct number of them.
- *
- * @param input the data to decode
- * @param offset the position within the input array at which to start
- * @param len the number of bytes of input to decode
- * @param flags controls certain features of the decoded output.
- * Pass {@code DEFAULT} to decode standard Base64.
- *
- * @throws IllegalArgumentException if the input contains
- * incorrect padding
- */
- public static byte[] decode(byte[] input, int offset, int len, int flags) {
- // Allocate space for the most data the input could represent.
- // (It could contain less if it contains whitespace, etc.)
- Decoder decoder = new Decoder(flags, new byte[len*3/4]);
- if (!decoder.process(input, offset, len, true)) {
- throw new IllegalArgumentException("bad base-64");
- }
- // Maybe we got lucky and allocated exactly enough output space.
- if (decoder.op == decoder.output.length) {
- return decoder.output;
- }
- // Need to shorten the array, so allocate a new one of the
- // right size and copy.
- byte[] temp = new byte[decoder.op];
- System.arraycopy(decoder.output, 0, temp, 0, decoder.op);
- return temp;
- }
- /* package */ static class Decoder extends Coder {
- /**
- * Lookup table for turning bytes into their position in the
- * Base64 alphabet.
- */
- private static final int DECODE[] = {
- -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
- -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
- -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 62, -1, -1, -1, 63,
- 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, -1, -1, -1, -2, -1, -1,
- -1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14,
- 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, -1, -1, -1, -1, -1,
- -1, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40,
- 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, -1, -1, -1, -1, -1,
- -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
- -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
- -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
- -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
- -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
- -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
- -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
- -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
- };
- /**
- * Decode lookup table for the "web safe" variant (RFC 3548
- * sec. 4) where - and _ replace + and /.
- */
- private static final int DECODE_WEBSAFE[] = {
- -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
- -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
- -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 62, -1, -1,
- 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, -1, -1, -1, -2, -1, -1,
- -1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14,
- 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, -1, -1, -1, -1, 63,
- -1, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40,
- 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, -1, -1, -1, -1, -1,
- -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
- -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
- -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
- -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
- -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
- -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
- -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
- -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
- };
- /** Non-data values in the DECODE arrays. */
- private static final int SKIP = -1;
- private static final int EQUALS = -2;
- /**
- * States 0-3 are reading through the next input tuple.
- * State 4 is having read one '=' and expecting exactly
- * one more.
- * State 5 is expecting no more data or padding characters
- * in the input.
- * State 6 is the error state; an error has been detected
- * in the input and no future input can "fix" it.
- */
- private int state; // state number (0 to 6)
- private int value;
- final private int[] alphabet;
- public Decoder(int flags, byte[] output) {
- this.output = output;
- alphabet = ((flags & URL_SAFE) == 0) ? DECODE : DECODE_WEBSAFE;
- state = 0;
- value = 0;
- }
- /**
- * @return an overestimate for the number of bytes {@code
- * len} bytes could decode to.
- */
- public int maxOutputSize(int len) {
- return len * 3/4 + 10;
- }
- /**
- * Decode another block of input data.
- *
- * @return true if the state machine is still healthy. false if
- * bad base-64 data has been detected in the input stream.
- */
- public boolean process(byte[] input, int offset, int len, boolean finish) {
- if (this.state == 6) return false;
- int p = offset;
- len += offset;
- // Using local variables makes the decoder about 12%
- // faster than if we manipulate the member variables in
- // the loop. (Even alphabet makes a measurable
- // difference, which is somewhat surprising to me since
- // the member variable is final.)
- int state = this.state;
- int value = this.value;
- int op = 0;
- final byte[] output = this.output;
- final int[] alphabet = this.alphabet;
- while (p < len) {
- // Try the fast path: we're starting a new tuple and the
- // next four bytes of the input stream are all data
- // bytes. This corresponds to going through states
- // 0-1-2-3-0. We expect to use this method for most of
- // the data.
- //
- // If any of the next four bytes of input are non-data
- // (whitespace, etc.), value will end up negative. (All
- // the non-data values in decode are small negative
- // numbers, so shifting any of them up and or'ing them
- // together will result in a value with its top bit set.)
- //
- // You can remove this whole block and the output should
- // be the same, just slower.
- if (state == 0) {
- while (p+4 <= len &&
- (value = ((alphabet[input[p] & 0xff] << 18) |
- (alphabet[input[p+1] & 0xff] << 12) |
- (alphabet[input[p+2] & 0xff] << 6) |
- (alphabet[input[p+3] & 0xff]))) >= 0) {
- output[op+2] = (byte) value;
- output[op+1] = (byte) (value >> 8);
- output[op] = (byte) (value >> 16);
- op += 3;
- p += 4;
- }
- if (p >= len) break;
- }
- // The fast path isn't available -- either we've read a
- // partial tuple, or the next four input bytes aren't all
- // data, or whatever. Fall back to the slower state
- // machine implementation.
- int d = alphabet[input[p++] & 0xff];
- switch (state) {
- case 0:
- if (d >= 0) {
- value = d;
- ++state;
- } else if (d != SKIP) {
- this.state = 6;
- return false;
- }
- break;
- case 1:
- if (d >= 0) {
- value = (value << 6) | d;
- ++state;
- } else if (d != SKIP) {
- this.state = 6;
- return false;
- }
- break;
- case 2:
- if (d >= 0) {
- value = (value << 6) | d;
- ++state;
- } else if (d == EQUALS) {
- // Emit the last (partial) output tuple;
- // expect exactly one more padding character.
- output[op++] = (byte) (value >> 4);
- state = 4;
- } else if (d != SKIP) {
- this.state = 6;
- return false;
- }
- break;
- case 3:
- if (d >= 0) {
- // Emit the output triple and return to state 0.
- value = (value << 6) | d;
- output[op+2] = (byte) value;
- output[op+1] = (byte) (value >> 8);
- output[op] = (byte) (value >> 16);
- op += 3;
- state = 0;
- } else if (d == EQUALS) {
- // Emit the last (partial) output tuple;
- // expect no further data or padding characters.
- output[op+1] = (byte) (value >> 2);
- output[op] = (byte) (value >> 10);
- op += 2;
- state = 5;
- } else if (d != SKIP) {
- this.state = 6;
- return false;
- }
- break;
- case 4:
- if (d == EQUALS) {
- ++state;
- } else if (d != SKIP) {
- this.state = 6;
- return false;
- }
- break;
- case 5:
- if (d != SKIP) {
- this.state = 6;
- return false;
- }
- break;
- }
- }
- if (!finish) {
- // We're out of input, but a future call could provide
- // more.
- this.state = state;
- this.value = value;
- this.op = op;
- return true;
- }
- // Done reading input. Now figure out where we are left in
- // the state machine and finish up.
- switch (state) {
- case 0:
- // Output length is a multiple of three. Fine.
- break;
- case 1:
- // Read one extra input byte, which isn't enough to
- // make another output byte. Illegal.
- this.state = 6;
- return false;
- case 2:
- // Read two extra input bytes, enough to emit 1 more
- // output byte. Fine.
- output[op++] = (byte) (value >> 4);
- break;
- case 3:
- // Read three extra input bytes, enough to emit 2 more
- // output bytes. Fine.
- output[op++] = (byte) (value >> 10);
- output[op++] = (byte) (value >> 2);
- break;
- case 4:
- // Read one padding '=' when we expected 2. Illegal.
- this.state = 6;
- return false;
- case 5:
- // Read all the padding '='s we expected and no more.
- // Fine.
- break;
- }
- this.state = state;
- this.op = op;
- return true;
- }
- }
- // --------------------------------------------------------
- // encoding
- // --------------------------------------------------------
- /**
- * Base64-encode the given data and return a newly allocated
- * String with the result.
- *
- * @param input the data to encode
- * @param flags controls certain features of the encoded output.
- * Passing {@code DEFAULT} results in output that
- * adheres to RFC 2045.
- */
- public static String encodeToString(byte[] input, int flags) {
- try {
- return new String(encode(input, flags), "US-ASCII");
- } catch (UnsupportedEncodingException e) {
- // US-ASCII is guaranteed to be available.
- throw new AssertionError(e);
- }
- }
- /**
- * Base64-encode the given data and return a newly allocated
- * String with the result.
- *
- * @param input the data to encode
- * @param offset the position within the input array at which to
- * start
- * @param len the number of bytes of input to encode
- * @param flags controls certain features of the encoded output.
- * Passing {@code DEFAULT} results in output that
- * adheres to RFC 2045.
- */
- public static String encodeToString(byte[] input, int offset, int len, int flags) {
- try {
- return new String(encode(input, offset, len, flags), "US-ASCII");
- } catch (UnsupportedEncodingException e) {
- // US-ASCII is guaranteed to be available.
- throw new AssertionError(e);
- }
- }
- /**
- * Base64-encode the given data and return a newly allocated
- * byte[] with the result.
- *
- * @param input the data to encode
- * @param flags controls certain features of the encoded output.
- * Passing {@code DEFAULT} results in output that
- * adheres to RFC 2045.
- */
- public static byte[] encode(byte[] input, int flags) {
- return encode(input, 0, input.length, flags);
- }
- /**
- * Base64-encode the given data and return a newly allocated
- * byte[] with the result.
- *
- * @param input the data to encode
- * @param offset the position within the input array at which to
- * start
- * @param len the number of bytes of input to encode
- * @param flags controls certain features of the encoded output.
- * Passing {@code DEFAULT} results in output that
- * adheres to RFC 2045.
- */
- public static byte[] encode(byte[] input, int offset, int len, int flags) {
- Encoder encoder = new Encoder(flags, null);
- // Compute the exact length of the array we will produce.
- int output_len = len / 3 * 4;
- // Account for the tail of the data and the padding bytes, if any.
- if (encoder.do_padding) {
- if (len % 3 > 0) {
- output_len += 4;
- }
- } else {
- switch (len % 3) {
- case 0: break;
- case 1: output_len += 2; break;
- case 2: output_len += 3; break;
- }
- }
- // Account for the newlines, if any.
- if (encoder.do_newline && len > 0) {
- output_len += (((len-1) / (3 * Encoder.LINE_GROUPS)) + 1) *
- (encoder.do_cr ? 2 : 1);
- }
- encoder.output = new byte[output_len];
- encoder.process(input, offset, len, true);
- assert encoder.op == output_len;
- return encoder.output;
- }
- /* package */ static class Encoder extends Coder {
- /**
- * Emit a new line every this many output tuples. Corresponds to
- * a 76-character line length (the maximum allowable according to
- * <a href="http://www.ietf.org/rfc/rfc2045.txt">RFC 2045</a>).
- */
- public static final int LINE_GROUPS = 19;
- /**
- * Lookup table for turning Base64 alphabet positions (6 bits)
- * into output bytes.
- */
- private static final byte ENCODE[] = {
- 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P',
- 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z', 'a', 'b', 'c', 'd', 'e', 'f',
- 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v',
- 'w', 'x', 'y', 'z', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '+', '/',
- };
- /**
- * Lookup table for turning Base64 alphabet positions (6 bits)
- * into output bytes.
- */
- private static final byte ENCODE_WEBSAFE[] = {
- 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P',
- 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z', 'a', 'b', 'c', 'd', 'e', 'f',
- 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v',
- 'w', 'x', 'y', 'z', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '-', '_',
- };
- final private byte[] tail;
- /* package */ int tailLen;
- private int count;
- final public boolean do_padding;
- final public boolean do_newline;
- final public boolean do_cr;
- final private byte[] alphabet;
- public Encoder(int flags, byte[] output) {
- this.output = output;
- do_padding = (flags & NO_PADDING) == 0;
- do_newline = (flags & NO_WRAP) == 0;
- do_cr = (flags & CRLF) != 0;
- alphabet = ((flags & URL_SAFE) == 0) ? ENCODE : ENCODE_WEBSAFE;
- tail = new byte[2];
- tailLen = 0;
- count = do_newline ? LINE_GROUPS : -1;
- }
- /**
- * @return an overestimate for the number of bytes {@code
- * len} bytes could encode to.
- */
- public int maxOutputSize(int len) {
- return len * 8/5 + 10;
- }
- public boolean process(byte[] input, int offset, int len, boolean finish) {
- // Using local variables makes the encoder about 9% faster.
- final byte[] alphabet = this.alphabet;
- final byte[] output = this.output;
- int op = 0;
- int count = this.count;
- int p = offset;
- len += offset;
- int v = -1;
- // First we need to concatenate the tail of the previous call
- // with any input bytes available now and see if we can empty
- // the tail.
- switch (tailLen) {
- case 0:
- // There was no tail.
- break;
- case 1:
- if (p+2 <= len) {
- // A 1-byte tail with at least 2 bytes of
- // input available now.
- v = ((tail[0] & 0xff) << 16) |
- ((input[p++] & 0xff) << 8) |
- (input[p++] & 0xff);
- tailLen = 0;
- };
- break;
- case 2:
- if (p+1 <= len) {
- // A 2-byte tail with at least 1 byte of input.
- v = ((tail[0] & 0xff) << 16) |
- ((tail[1] & 0xff) << 8) |
- (input[p++] & 0xff);
- tailLen = 0;
- }
- break;
- }
- if (v != -1) {
- output[op++] = alphabet[(v >> 18) & 0x3f];
- output[op++] = alphabet[(v >> 12) & 0x3f];
- output[op++] = alphabet[(v >> 6) & 0x3f];
- output[op++] = alphabet[v & 0x3f];
- if (--count == 0) {
- if (do_cr) output[op++] = '\r';
- output[op++] = '\n';
- count = LINE_GROUPS;
- }
- }
- // At this point either there is no tail, or there are fewer
- // than 3 bytes of input available.
- // The main loop, turning 3 input bytes into 4 output bytes on
- // each iteration.
- while (p+3 <= len) {
- v = ((input[p] & 0xff) << 16) |
- ((input[p+1] & 0xff) << 8) |
- (input[p+2] & 0xff);
- output[op] = alphabet[(v >> 18) & 0x3f];
- output[op+1] = alphabet[(v >> 12) & 0x3f];
- output[op+2] = alphabet[(v >> 6) & 0x3f];
- output[op+3] = alphabet[v & 0x3f];
- p += 3;
- op += 4;
- if (--count == 0) {
- if (do_cr) output[op++] = '\r';
- output[op++] = '\n';
- count = LINE_GROUPS;
- }
- }
- if (finish) {
- // Finish up the tail of the input. Note that we need to
- // consume any bytes in tail before any bytes
- // remaining in input; there should be at most two bytes
- // total.
- if (p-tailLen == len-1) {
- int t = 0;
- v = ((tailLen > 0 ? tail[t++] : input[p++]) & 0xff) << 4;
- tailLen -= t;
- output[op++] = alphabet[(v >> 6) & 0x3f];
- output[op++] = alphabet[v & 0x3f];
- if (do_padding) {
- output[op++] = '=';
- output[op++] = '=';
- }
- if (do_newline) {
- if (do_cr) output[op++] = '\r';
- output[op++] = '\n';
- }
- } else if (p-tailLen == len-2) {
- int t = 0;
- v = (((tailLen > 1 ? tail[t++] : input[p++]) & 0xff) << 10) |
- (((tailLen > 0 ? tail[t++] : input[p++]) & 0xff) << 2);
- tailLen -= t;
- output[op++] = alphabet[(v >> 12) & 0x3f];
- output[op++] = alphabet[(v >> 6) & 0x3f];
- output[op++] = alphabet[v & 0x3f];
- if (do_padding) {
- output[op++] = '=';
- }
- if (do_newline) {
- if (do_cr) output[op++] = '\r';
- output[op++] = '\n';
- }
- } else if (do_newline && op > 0 && count != LINE_GROUPS) {
- if (do_cr) output[op++] = '\r';
- output[op++] = '\n';
- }
- assert tailLen == 0;
- assert p == len;
- } else {
- // Save the leftovers in tail to be consumed on the next
- // call to encodeInternal.
- if (p == len-1) {
- tail[tailLen++] = input[p];
- } else if (p == len-2) {
- tail[tailLen++] = input[p];
- tail[tailLen++] = input[p+1];
- }
- }
- this.op = op;
- this.count = count;
- return true;
- }
- }
- private Base64() { } // don't instantiate
- }
Object-C:
- /*** JoDes.h ***/
- #import <Foundation/Foundation.h>
- #import <CommonCrypto/CommonDigest.h>
- #import <CommonCrypto/CommonCryptor.h>
- @interface JoDes : NSObject
- + (NSString *) encode:(NSString *)str key:(NSString *)key;
- + (NSString *) decode:(NSString *)str key:(NSString *)key;
- @end
- /*** JoDes.m ***/
- //
- // XLEncrytHelper.m
- // NewHoldGold
- //
- // Created by 梁鑫磊 on 13-12-27.
- // Copyright (c) 2013年 zsgjs. All rights reserved.
- //
- #import "JoDes.h"
- @interface JoDes()
- + (NSString *) encodeBase64WithString:(NSString *)strData;
- + (NSString *) encodeBase64WithData:(NSData *)objData;
- + (NSData *) decodeBase64WithString:(NSString *)strBase64;
- + (NSString *)doCipher:(NSString *)sTextIn key:(NSString *)sKey
- context:(CCOperation)encryptOrDecrypt;
- @end
- @implementation JoDes
- + (NSString *) encode:(NSString *)str key:(NSString *)key
- {
- // doCipher 不能编汉字,所以要进行 url encode
- NSMutableString* str1 = [JoDes urlEncode:str];
- NSMutableString* encode = [NSMutableString stringWithString:[JoDes doCipher:str1 key:key context:kCCEncrypt]];
- [JoDes formatSpecialCharacters:encode];
- return encode;
- }
- + (NSString *) decode:(NSString *)str key:(NSString *)key
- {
- NSMutableString *str1 = [NSMutableString stringWithString:str];
- [JoDes reformatSpecialCharacters:str1];
- NSString *rt = [JoDes doCipher:str1 key:key context:kCCDecrypt];
- return rt;
- }
- + (NSMutableString *)urlEncode:(NSString*)str
- {
- NSMutableString* encodeStr = [NSMutableString stringWithString:[str stringByAddingPercentEscapesUsingEncoding:NSUTF8StringEncoding]];
- [encodeStr replaceOccurrencesOfString:@"+" withString:@"%2B" options:NSWidthInsensitiveSearch range:NSMakeRange(0, [encodeStr length])];
- [encodeStr replaceOccurrencesOfString:@"/" withString:@"%2F" options:NSWidthInsensitiveSearch range:NSMakeRange(0, [encodeStr length])];
- return encodeStr;
- }
- + (void)formatSpecialCharacters:(NSMutableString *)str
- {
- [str replaceOccurrencesOfString:@"+" withString:@"$$" options:NSWidthInsensitiveSearch range:NSMakeRange(0, [str length])];
- [str replaceOccurrencesOfString:@"/" withString:@"@@" options:NSWidthInsensitiveSearch range:NSMakeRange(0, [str length])];
- }
- + (void)reformatSpecialCharacters:(NSMutableString *)str
- {
- [str replaceOccurrencesOfString:@"$$" withString:@"+" options:NSWidthInsensitiveSearch range:NSMakeRange(0, [str length])];
- [str replaceOccurrencesOfString:@"@@" withString:@"/" options:NSWidthInsensitiveSearch range:NSMakeRange(0, [str length])];
- }
- + (NSString *)encodeBase64WithString:(NSString *)strData {
- return [JoDes encodeBase64WithData:[strData dataUsingEncoding:NSUTF8StringEncoding]];
- }
- + (NSString *)encodeBase64WithData:(NSData *)objData {
- NSString *encoding = nil;
- unsigned charchar *encodingBytes = NULL;
- @try {
- static char encodingTable[64] = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
- static NSUInteger paddingTable[] = {0,2,1};
- NSUInteger dataLength = [objData length];
- NSUInteger encodedBlocks = (dataLength * 8) / 24;
- NSUInteger padding = paddingTable[dataLength % 3];
- if( padding > 0 ) encodedBlocks++;
- NSUInteger encodedLength = encodedBlocks * 4;
- encodingBytes = malloc(encodedLength);
- if( encodingBytes != NULL ) {
- NSUInteger rawBytesToProcess = dataLength;
- NSUInteger rawBaseIndex = 0;
- NSUInteger encodingBaseIndex = 0;
- unsigned charchar *rawBytes = (unsigned charchar *)[objData bytes];
- unsigned char rawByte1, rawByte2, rawByte3;
- while( rawBytesToProcess >= 3 ) {
- rawByte1 = rawBytes[rawBaseIndex];
- rawByte2 = rawBytes[rawBaseIndex+1];
- rawByte3 = rawBytes[rawBaseIndex+2];
- encodingBytes[encodingBaseIndex] = encodingTable[((rawByte1 >> 2) & 0x3F)];
- encodingBytes[encodingBaseIndex+1] = encodingTable[((rawByte1 << 4) & 0x30) | ((rawByte2 >> 4) & 0x0F) ];
- encodingBytes[encodingBaseIndex+2] = encodingTable[((rawByte2 << 2) & 0x3C) | ((rawByte3 >> 6) & 0x03) ];
- encodingBytes[encodingBaseIndex+3] = encodingTable[(rawByte3 & 0x3F)];
- rawBaseIndex += 3;
- encodingBaseIndex += 4;
- rawBytesToProcess -= 3;
- }
- rawByte2 = 0;
- switch (dataLength-rawBaseIndex) {
- case 2:
- rawByte2 = rawBytes[rawBaseIndex+1];
- case 1:
- rawByte1 = rawBytes[rawBaseIndex];
- encodingBytes[encodingBaseIndex] = encodingTable[((rawByte1 >> 2) & 0x3F)];
- encodingBytes[encodingBaseIndex+1] = encodingTable[((rawByte1 << 4) & 0x30) | ((rawByte2 >> 4) & 0x0F) ];
- encodingBytes[encodingBaseIndex+2] = encodingTable[((rawByte2 << 2) & 0x3C) ];
- // we can skip rawByte3 since we have a partial block it would always be 0
- break;
- }
- // compute location from where to begin inserting padding, it may overwrite some bytes from the partial block encoding
- // if their value was 0 (cases 1-2).
- encodingBaseIndex = encodedLength - padding;
- while( padding-- > 0 ) {
- encodingBytes[encodingBaseIndex++] = '=';
- }
- encoding = [[NSString alloc] initWithBytes:encodingBytes length:encodedLength encoding:NSASCIIStringEncoding];
- }
- }
- @catch (NSException *exception) {
- encoding = nil;
- NSLog(@"WARNING: error occured while tring to encode base 32 data: %@", exception);
- }
- @finally {
- if( encodingBytes != NULL ) {
- free( encodingBytes );
- }
- }
- return encoding;
- }
- + (NSData *)decodeBase64WithString:(NSString *)strBase64 {
- NSData *data = nil;
- unsigned charchar *decodedBytes = NULL;
- @try {
- #define __ 255
- static char decodingTable[256] = {
- __,__,__,__, __,__,__,__, __,__,__,__, __,__,__,__, // 0x00 - 0x0F
- __,__,__,__, __,__,__,__, __,__,__,__, __,__,__,__, // 0x10 - 0x1F
- __,__,__,__, __,__,__,__, __,__,__,62, __,__,__,63, // 0x20 - 0x2F
- 52,53,54,55, 56,57,58,59, 60,61,__,__, __, 0,__,__, // 0x30 - 0x3F
- __, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9,10, 11,12,13,14, // 0x40 - 0x4F
- 15,16,17,18, 19,20,21,22, 23,24,25,__, __,__,__,__, // 0x50 - 0x5F
- __,26,27,28, 29,30,31,32, 33,34,35,36, 37,38,39,40, // 0x60 - 0x6F
- 41,42,43,44, 45,46,47,48, 49,50,51,__, __,__,__,__, // 0x70 - 0x7F
- __,__,__,__, __,__,__,__, __,__,__,__, __,__,__,__, // 0x80 - 0x8F
- __,__,__,__, __,__,__,__, __,__,__,__, __,__,__,__, // 0x90 - 0x9F
- __,__,__,__, __,__,__,__, __,__,__,__, __,__,__,__, // 0xA0 - 0xAF
- __,__,__,__, __,__,__,__, __,__,__,__, __,__,__,__, // 0xB0 - 0xBF
- __,__,__,__, __,__,__,__, __,__,__,__, __,__,__,__, // 0xC0 - 0xCF
- __,__,__,__, __,__,__,__, __,__,__,__, __,__,__,__, // 0xD0 - 0xDF
- __,__,__,__, __,__,__,__, __,__,__,__, __,__,__,__, // 0xE0 - 0xEF
- __,__,__,__, __,__,__,__, __,__,__,__, __,__,__,__, // 0xF0 - 0xFF
- };
- strBase64 = [strBase64 stringByReplacingOccurrencesOfString:@"=" withString:@""];
- NSData *encodedData = [strBase64 dataUsingEncoding:NSASCIIStringEncoding];
- unsigned charchar *encodedBytes = (unsigned charchar *)[encodedData bytes];
- NSUInteger encodedLength = [encodedData length];
- NSUInteger encodedBlocks = (encodedLength+3) >> 2;
- NSUInteger expectedDataLength = encodedBlocks * 3;
- unsigned char decodingBlock[4];
- decodedBytes = malloc(expectedDataLength);
- if( decodedBytes != NULL ) {
- NSUInteger i = 0;
- NSUInteger j = 0;
- NSUInteger k = 0;
- unsigned char c;
- while( i < encodedLength ) {
- c = decodingTable[encodedBytes[i]];
- i++;
- if( c != __ ) {
- decodingBlock[j] = c;
- j++;
- if( j == 4 ) {
- decodedBytes[k] = (decodingBlock[0] << 2) | (decodingBlock[1] >> 4);
- decodedBytes[k+1] = (decodingBlock[1] << 4) | (decodingBlock[2] >> 2);
- decodedBytes[k+2] = (decodingBlock[2] << 6) | (decodingBlock[3]);
- j = 0;
- k += 3;
- }
- }
- }
- // Process left over bytes, if any
- if( j == 3 ) {
- decodedBytes[k] = (decodingBlock[0] << 2) | (decodingBlock[1] >> 4);
- decodedBytes[k+1] = (decodingBlock[1] << 4) | (decodingBlock[2] >> 2);
- k += 2;
- } else if( j == 2 ) {
- decodedBytes[k] = (decodingBlock[0] << 2) | (decodingBlock[1] >> 4);
- k += 1;
- }
- data = [[NSData alloc] initWithBytes:decodedBytes length:k];
- }
- }
- @catch (NSException *exception) {
- data = nil;
- NSLog(@"WARNING: error occured while decoding base 32 string: %@", exception);
- }
- @finally {
- if( decodedBytes != NULL ) {
- free( decodedBytes );
- }
- }
- return data;
- }
- + (NSString *)doCipher:(NSString *)sTextIn key:(NSString *)sKey
- context:(CCOperation)encryptOrDecrypt {
- NSStringEncoding EnC = NSUTF8StringEncoding;
- NSMutableData *dTextIn;
- if (encryptOrDecrypt == kCCDecrypt) {
- dTextIn = [[JoDes decodeBase64WithString:sTextIn] mutableCopy];
- }
- else{
- dTextIn = [[sTextIn dataUsingEncoding: EnC] mutableCopy];
- }
- NSMutableData * dKey = [[sKey dataUsingEncoding:EnC] mutableCopy];
- [dKey setLength:kCCBlockSizeDES];
- uint8_t *bufferPtr1 = NULL;
- size_t bufferPtrSize1 = 0;
- size_t movedBytes1 = 0;
- //uint8_t iv[kCCBlockSizeDES];
- //memset((void *) iv, 0x0, (size_t) sizeof(iv));
- // Byte iv[] = {0x12, 0x34, 0x56, 0x78, 0x90, 0xAB, 0xCD, 0xEF};
- bufferPtrSize1 = ([sTextIn length] + kCCKeySizeDES) & ~(kCCKeySizeDES -1);
- bufferPtr1 = malloc(bufferPtrSize1 * sizeof(uint8_t));
- memset((voidvoid *)bufferPtr1, 0x00, bufferPtrSize1);
- CCCrypt(encryptOrDecrypt, // CCOperation op
- kCCAlgorithmDES, // CCAlgorithm alg
- kCCOptionPKCS7Padding, // CCOptions options
- [dKey bytes], // const void *key
- [dKey length], // size_t keyLength //
- [dKey bytes], // const void *iv
- [dTextIn bytes], // const void *dataIn
- [dTextIn length], // size_t dataInLength
- (voidvoid *)bufferPtr1, // void *dataOut
- bufferPtrSize1, // size_t dataOutAvailable
- &movedBytes1);
- //[dTextIn release];
- //[dKey release];
- NSString * sResult;
- if (encryptOrDecrypt == kCCDecrypt){
- sResult = [[NSString alloc] initWithData:[NSData dataWithBytes:bufferPtr1 length:movedBytes1] encoding:EnC];
- free(bufferPtr1);
- }
- else {
- NSData *dResult = [NSData dataWithBytes:bufferPtr1 length:movedBytes1];
- free(bufferPtr1);
- sResult = [JoDes encodeBase64WithData:dResult];
- }
- return sResult;
- }
- @end