原文:DES加密和解密PHP，Java，ObjectC统一的方法

PHP的加解密函数

  1. <?php
  2.  
  3. class DesComponent {
  4. 	var $key = '12345678';
  5.  
  6. 	function encrypt($string) {
  7.  
  8. 		$ivArray=array(0x12, 0x34, 0x56, 0x78, 0x90, 0xAB, 0xCD, 0xEF);
  9. 		$iv=null;
  10. 		foreach ($ivArray as $element)
  11. 			$iv.=CHR($element);
  12.  
  13.  		$size = mcrypt_get_block_size ( MCRYPT_DES, MCRYPT_MODE_CBC );
  14.        $string = $this->pkcs5Pad ( $string, $size );  
  15.  
  16. 		$data =  mcrypt_encrypt(MCRYPT_DES, $this->key, $string, MCRYPT_MODE_CBC, $iv);
  17.  
  18. 		$data = base64_encode($data);
  19. 		return $data;
  20. 	}
  21.  
  22. 	function decrypt($string) {
  23.  
  24. 		$ivArray=array(0x12, 0x34, 0x56, 0x78, 0x90, 0xAB, 0xCD, 0xEF);
  25. 		$iv=null;
  26. 		foreach ($ivArray as $element)
  27. 			$iv.=CHR($element);
  28.  
  29. 		$string = base64_decode($string);
  30. 		//echo("****");
  31. 		//echo($string);
  32. 		//echo("****");
  33. 		$result =  mcrypt_decrypt(MCRYPT_DES, $this->key, $string, MCRYPT_MODE_CBC, $iv);
  34.    $result = $this->pkcs5Unpad( $result );  
  35.  
  36. 		return $result;
  37. 	}
  38.  
  39. 	 function pkcs5Pad($text, $blocksize)
  40.     {
  41.         $pad = $blocksize - (strlen ( $text ) % $blocksize);
  42.         return $text . str_repeat ( chr ( $pad ), $pad );
  43.     }  
  44.  
  45.     function pkcs5Unpad($text)
  46.     {
  47.         $pad = ord ( $text {strlen ( $text ) - 1} );
  48.         if ($pad > strlen ( $text ))
  49.             return false;
  50.         if (strspn ( $text, chr ( $pad ), strlen ( $text ) - $pad ) != $pad)
  51.             return false;
  52.         return substr ( $text, 0, - 1 * $pad );
  53.     }  
  54.  
  55. }
  56.  
  57. $des = new DesComponent();
  58. echo ($des->encrypt("19760519"));
  59. echo "<br />";
  60.  
  61. //die($des->decrypt("zLVdpYUM0qw="));
  62. //die($des->decrypt("zLVdpYUM0qzEsNshEEI6Cg=="));
  63.  
  64. $t2 =$des->decrypt("zLVdpYUM0qw=");
  65. echo $t2;
  66. echo "--";
  67. echo strlen($t2);
  68. echo is_utf8($t2);
  69.  
  70. echo "<br />";
  71. $t3 = mb_convert_encoding($t2,"GB2312", "utf-8");
  72. echo $t3;
  73. echo "--";
  74. echo strlen($t3);
  75. echo is_utf8($t3);
  76.  
  77. echo "<br />";
  78.  
  79. $t1 =$des->decrypt("zLVdpYUM0qzEsNshEEI6Cg==");
  80. echo $t1;
  81. echo "--";
  82. echo strlen($t1);
  83. echo is_utf8($t1);
  84.  
  85. echo "<br />";
  86. $t3 = mb_convert_encoding($t1, "utf-8","GB2312");
  87. echo $t3;
  88. echo "--";
  89. echo strlen($t3);
  90. echo is_utf8($t3);
  91.  
  92. function is_utf8($string) {
  93. return preg_match('%^(?:
  94. [\x09\x0A\x0D\x20-\x7E] # ASCII
  95. | [\xC2-\xDF][\x80-\xBF] # non-overlong 2-byte
  96. | \xE0[\xA0-\xBF][\x80-\xBF] # excluding overlongs
  97. | [\xE1-\xEC\xEE\xEF][\x80-\xBF]{2} # straight 3-byte
  98. | \xED[\x80-\x9F][\x80-\xBF] # excluding surrogates
  99. | \xF0[\x90-\xBF][\x80-\xBF]{2} # planes 1-3
  100. | [\xF1-\xF3][\x80-\xBF]{3} # planes 4-15
  101. | \xF4[\x80-\x8F][\x80-\xBF]{2} # plane 16
  102. )*$%xs', $string);
  103. }
  104. ?>

Java的加解密函数

  1. package ghj1976.Demo;
  2.  
  3. /*
  4.  * Copyright (C) 2010 The Android Open Source Project
  5.  *
  6.  * Licensed under the Apache License, Version 2.0 (the "License");
  7.  * you may not use this file except in compliance with the License.
  8.  * You may obtain a copy of the License at
  9.  *
  10.  *      http://www.apache.org/licenses/LICENSE-2.0
  11.  *
  12.  * Unless required by applicable law or agreed to in writing, software
  13.  * distributed under the License is distributed on an "AS IS" BASIS,
  14.  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  15.  * See the License for the specific language governing permissions and
  16.  * limitations under the License.
  17.  */
  18.  
  19. import java.io.UnsupportedEncodingException;
  20.  
  21. /**
  22.  * Utilities for encoding and decoding the Base64 representation of
  23.  * binary data.  See RFCs <a
  24.  * href="http://www.ietf.org/rfc/rfc2045.txt">2045</a> and <a
  25.  * href="http://www.ietf.org/rfc/rfc3548.txt">3548</a>.
  26.  */
  27. public class Base64 {
  28.     /**
  29.      * Default values for encoder/decoder flags.
  30.      */
  31.     public static final int DEFAULT = 0;
  32.  
  33.     /**
  34.      * Encoder flag bit to omit the padding '=' characters at the end
  35.      * of the output (if any).
  36.      */
  37.     public static final int NO_PADDING = 1;
  38.  
  39.     /**
  40.      * Encoder flag bit to omit all line terminators (i.e., the output
  41.      * will be on one long line).
  42.      */
  43.     public static final int NO_WRAP = 2;
  44.  
  45.     /**
  46.      * Encoder flag bit to indicate lines should be terminated with a
  47.      * CRLF pair instead of just an LF.  Has no effect if {@code
  48.      * NO_WRAP} is specified as well.
  49.      */
  50.     public static final int CRLF = 4;
  51.  
  52.     /**
  53.      * Encoder/decoder flag bit to indicate using the "URL and
  54.      * filename safe" variant of Base64 (see RFC 3548 section 4) where
  55.      * {@code -} and {@code _} are used in place of {@code +} and
  56.      * {@code /}.
  57.      */
  58.     public static final int URL_SAFE = 8;
  59.  
  60.     /**
  61.      * Flag to pass to {@link Base64OutputStream} to indicate that it
  62.      * should not close the output stream it is wrapping when it
  63.      * itself is closed.
  64.      */
  65.     public static final int NO_CLOSE = 16;
  66.  
  67.     //  --------------------------------------------------------
  68.     //  shared code
  69.     //  --------------------------------------------------------
  70.  
  71.     /* package */ static abstract class Coder {
  72.         public byte[] output;
  73.         public int op;
  74.  
  75.         /**
  76.          * Encode/decode another block of input data.  this.output is
  77.          * provided by the caller, and must be big enough to hold all
  78.          * the coded data.  On exit, this.opwill be set to the length
  79.          * of the coded data.
  80.          *
  81.          * @param finish true if this is the final call to process for
  82.          *        this object.  Will finalize the coder state and
  83.          *        include any final bytes in the output.
  84.          *
  85.          * @return true if the input so far is good; false if some
  86.          *         error has been detected in the input stream..
  87.          */
  88.         public abstract boolean process(byte[] input, int offset, int len, boolean finish);
  89.  
  90.         /**
  91.          * @return the maximum number of bytes a call to process()
  92.          * could produce for the given number of input bytes.  This may
  93.          * be an overestimate.
  94.          */
  95.         public abstract int maxOutputSize(int len);
  96.     }
  97.  
  98.     //  --------------------------------------------------------
  99.     //  decoding
  100.     //  --------------------------------------------------------
  101.  
  102.     /**
  103.      * Decode the Base64-encoded data in input and return the data in
  104.      * a new byte array.
  105.      *
  106.      * <p>The padding '=' characters at the end are considered optional, but
  107.      * if any are present, there must be the correct number of them.
  108.      *
  109.      * @param str    the input String to decode, which is converted to
  110.      *               bytes using the default charset
  111.      * @param flags  controls certain features of the decoded output.
  112.      *               Pass {@code DEFAULT} to decode standard Base64.
  113.      *
  114.      * @throws IllegalArgumentException if the input contains
  115.      * incorrect padding
  116.      */
  117.     public static byte[] decode(String str, int flags) {
  118.         return decode(str.getBytes(), flags);
  119.     }
  120.  
  121.     /**
  122.      * Decode the Base64-encoded data in input and return the data in
  123.      * a new byte array.
  124.      *
  125.      * <p>The padding '=' characters at the end are considered optional, but
  126.      * if any are present, there must be the correct number of them.
  127.      *
  128.      * @param input the input array to decode
  129.      * @param flags  controls certain features of the decoded output.
  130.      *               Pass {@code DEFAULT} to decode standard Base64.
  131.      *
  132.      * @throws IllegalArgumentException if the input contains
  133.      * incorrect padding
  134.      */
  135.     public static byte[] decode(byte[] input, int flags) {
  136.         return decode(input, 0, input.length, flags);
  137.     }
  138.  
  139.     /**
  140.      * Decode the Base64-encoded data in input and return the data in
  141.      * a new byte array.
  142.      *
  143.      * <p>The padding '=' characters at the end are considered optional, but
  144.      * if any are present, there must be the correct number of them.
  145.      *
  146.      * @param input  the data to decode
  147.      * @param offset the position within the input array at which to start
  148.      * @param len    the number of bytes of input to decode
  149.      * @param flags  controls certain features of the decoded output.
  150.      *               Pass {@code DEFAULT} to decode standard Base64.
  151.      *
  152.      * @throws IllegalArgumentException if the input contains
  153.      * incorrect padding
  154.      */
  155.     public static byte[] decode(byte[] input, int offset, int len, int flags) {
  156.         // Allocate space for the most data the input could represent.
  157.         // (It could contain less if it contains whitespace, etc.)
  158.         Decoder decoder = new Decoder(flags, new byte[len*3/4]);
  159.  
  160.         if (!decoder.process(input, offset, len, true)) {
  161.             throw new IllegalArgumentException("bad base-64");
  162.         }
  163.  
  164.         // Maybe we got lucky and allocated exactly enough output space.
  165.         if (decoder.op == decoder.output.length) {
  166.             return decoder.output;
  167.         }
  168.  
  169.         // Need to shorten the array, so allocate a new one of the
  170.         // right size and copy.
  171.         byte[] temp = new byte[decoder.op];
  172.         System.arraycopy(decoder.output, 0, temp, 0, decoder.op);
  173.         return temp;
  174.     }
  175.  
  176.     /* package */ static class Decoder extends Coder {
  177.         /**
  178.          * Lookup table for turning bytes into their position in the
  179.          * Base64 alphabet.
  180.          */
  181.         private static final int DECODE[] = {
  182.             -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
  183.             -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
  184.             -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 62, -1, -1, -1, 63,
  185.             52, 53, 54, 55, 56, 57, 58, 59, 60, 61, -1, -1, -1, -2, -1, -1,
  186.             -1,  0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14,
  187.             15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, -1, -1, -1, -1, -1,
  188.             -1, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40,
  189.             41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, -1, -1, -1, -1, -1,
  190.             -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
  191.             -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
  192.             -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
  193.             -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
  194.             -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
  195.             -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
  196.             -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
  197.             -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
  198.         };
  199.  
  200.         /**
  201.          * Decode lookup table for the "web safe" variant (RFC 3548
  202.          * sec. 4) where - and _ replace + and /.
  203.          */
  204.         private static final int DECODE_WEBSAFE[] = {
  205.             -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
  206.             -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
  207.             -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 62, -1, -1,
  208.             52, 53, 54, 55, 56, 57, 58, 59, 60, 61, -1, -1, -1, -2, -1, -1,
  209.             -1,  0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14,
  210.             15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, -1, -1, -1, -1, 63,
  211.             -1, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40,
  212.             41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, -1, -1, -1, -1, -1,
  213.             -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
  214.             -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
  215.             -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
  216.             -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
  217.             -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
  218.             -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
  219.             -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
  220.             -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
  221.         };
  222.  
  223.         /** Non-data values in the DECODE arrays. */
  224.         private static final int SKIP = -1;
  225.         private static final int EQUALS = -2;
  226.  
  227.         /**
  228.          * States 0-3 are reading through the next input tuple.
  229.          * State 4 is having read one '=' and expecting exactly
  230.          * one more.
  231.          * State 5 is expecting no more data or padding characters
  232.          * in the input.
  233.          * State 6 is the error state; an error has been detected
  234.          * in the input and no future input can "fix" it.
  235.          */
  236.         private int state;   // state number (0 to 6)
  237.         private int value;
  238.  
  239.         final private int[] alphabet;
  240.  
  241.         public Decoder(int flags, byte[] output) {
  242.             this.output = output;
  243.  
  244.             alphabet = ((flags & URL_SAFE) == 0) ? DECODE : DECODE_WEBSAFE;
  245.             state = 0;
  246.             value = 0;
  247.         }
  248.  
  249.         /**
  250.          * @return an overestimate for the number of bytes {@code
  251.          * len} bytes could decode to.
  252.          */
  253.         public int maxOutputSize(int len) {
  254.             return len * 3/4 + 10;
  255.         }
  256.  
  257.         /**
  258.          * Decode another block of input data.
  259.          *
  260.          * @return true if the state machine is still healthy.  false if
  261.          *         bad base-64 data has been detected in the input stream.
  262.          */
  263.         public boolean process(byte[] input, int offset, int len, boolean finish) {
  264.             if (this.state == 6) return false;
  265.  
  266.             int p = offset;
  267.             len += offset;
  268.  
  269.             // Using local variables makes the decoder about 12%
  270.             // faster than if we manipulate the member variables in
  271.             // the loop.  (Even alphabet makes a measurable
  272.             // difference, which is somewhat surprising to me since
  273.             // the member variable is final.)
  274.             int state = this.state;
  275.             int value = this.value;
  276.             int op = 0;
  277.             final byte[] output = this.output;
  278.             final int[] alphabet = this.alphabet;
  279.  
  280.             while (p < len) {
  281.                 // Try the fast path:  we're starting a new tuple and the
  282.                 // next four bytes of the input stream are all data
  283.                 // bytes.  This corresponds to going through states
  284.                 // 0-1-2-3-0.  We expect to use this method for most of
  285.                 // the data.
  286.                 //
  287.                 // If any of the next four bytes of input are non-data
  288.                 // (whitespace, etc.), value will end up negative.  (All
  289.                 // the non-data values in decode are small negative
  290.                 // numbers, so shifting any of them up and or'ing them
  291.                 // together will result in a value with its top bit set.)
  292.                 //
  293.                 // You can remove this whole block and the output should
  294.                 // be the same, just slower.
  295.                 if (state == 0) {
  296.                     while (p+4 <= len &&
  297.                            (value = ((alphabet[input[p] & 0xff] << 18) |
  298.                                      (alphabet[input[p+1] & 0xff] << 12) |
  299.                                      (alphabet[input[p+2] & 0xff] << 6) |
  300.                                      (alphabet[input[p+3] & 0xff]))) >= 0) {
  301.                         output[op+2] = (byte) value;
  302.                         output[op+1] = (byte) (value >> 8);
  303.                         output[op] = (byte) (value >> 16);
  304.                         op += 3;
  305.                         p += 4;
  306.                     }
  307.                     if (p >= len) break;
  308.                 }
  309.  
  310.                 // The fast path isn't available -- either we've read a
  311.                 // partial tuple, or the next four input bytes aren't all
  312.                 // data, or whatever.  Fall back to the slower state
  313.                 // machine implementation.
  314.  
  315.                 int d = alphabet[input[p++] & 0xff];
  316.  
  317.                 switch (state) {
  318.                 case 0:
  319.                     if (d >= 0) {
  320.                         value = d;
  321.                         ++state;
  322.                     } else if (d != SKIP) {
  323.                         this.state = 6;
  324.                         return false;
  325.                     }
  326.                     break;
  327.  
  328.                 case 1:
  329.                     if (d >= 0) {
  330.                         value = (value << 6) | d;
  331.                         ++state;
  332.                     } else if (d != SKIP) {
  333.                         this.state = 6;
  334.                         return false;
  335.                     }
  336.                     break;
  337.  
  338.                 case 2:
  339.                     if (d >= 0) {
  340.                         value = (value << 6) | d;
  341.                         ++state;
  342.                     } else if (d == EQUALS) {
  343.                         // Emit the last (partial) output tuple;
  344.                         // expect exactly one more padding character.
  345.                         output[op++] = (byte) (value >> 4);
  346.                         state = 4;
  347.                     } else if (d != SKIP) {
  348.                         this.state = 6;
  349.                         return false;
  350.                     }
  351.                     break;
  352.  
  353.                 case 3:
  354.                     if (d >= 0) {
  355.                         // Emit the output triple and return to state 0.
  356.                         value = (value << 6) | d;
  357.                         output[op+2] = (byte) value;
  358.                         output[op+1] = (byte) (value >> 8);
  359.                         output[op] = (byte) (value >> 16);
  360.                         op += 3;
  361.                         state = 0;
  362.                     } else if (d == EQUALS) {
  363.                         // Emit the last (partial) output tuple;
  364.                         // expect no further data or padding characters.
  365.                         output[op+1] = (byte) (value >> 2);
  366.                         output[op] = (byte) (value >> 10);
  367.                         op += 2;
  368.                         state = 5;
  369.                     } else if (d != SKIP) {
  370.                         this.state = 6;
  371.                         return false;
  372.                     }
  373.                     break;
  374.  
  375.                 case 4:
  376.                     if (d == EQUALS) {
  377.                         ++state;
  378.                     } else if (d != SKIP) {
  379.                         this.state = 6;
  380.                         return false;
  381.                     }
  382.                     break;
  383.  
  384.                 case 5:
  385.                     if (d != SKIP) {
  386.                         this.state = 6;
  387.                         return false;
  388.                     }
  389.                     break;
  390.                 }
  391.             }
  392.  
  393.             if (!finish) {
  394.                 // We're out of input, but a future call could provide
  395.                 // more.
  396.                 this.state = state;
  397.                 this.value = value;
  398.                 this.op = op;
  399.                 return true;
  400.             }
  401.  
  402.             // Done reading input.  Now figure out where we are left in
  403.             // the state machine and finish up.
  404.  
  405.             switch (state) {
  406.             case 0:
  407.                 // Output length is a multiple of three.  Fine.
  408.                 break;
  409.             case 1:
  410.                 // Read one extra input byte, which isn't enough to
  411.                 // make another output byte.  Illegal.
  412.                 this.state = 6;
  413.                 return false;
  414.             case 2:
  415.                 // Read two extra input bytes, enough to emit 1 more
  416.                 // output byte.  Fine.
  417.                 output[op++] = (byte) (value >> 4);
  418.                 break;
  419.             case 3:
  420.                 // Read three extra input bytes, enough to emit 2 more
  421.                 // output bytes.  Fine.
  422.                 output[op++] = (byte) (value >> 10);
  423.                 output[op++] = (byte) (value >> 2);
  424.                 break;
  425.             case 4:
  426.                 // Read one padding '=' when we expected 2.  Illegal.
  427.                 this.state = 6;
  428.                 return false;
  429.             case 5:
  430.                 // Read all the padding '='s we expected and no more.
  431.                 // Fine.
  432.                 break;
  433.             }
  434.  
  435.             this.state = state;
  436.             this.op = op;
  437.             return true;
  438.         }
  439.     }
  440.  
  441.     //  --------------------------------------------------------
  442.     //  encoding
  443.     //  --------------------------------------------------------
  444.  
  445.     /**
  446.      * Base64-encode the given data and return a newly allocated
  447.      * String with the result.
  448.      *
  449.      * @param input  the data to encode
  450.      * @param flags  controls certain features of the encoded output.
  451.      *               Passing {@code DEFAULT} results in output that
  452.      *               adheres to RFC 2045.
  453.      */
  454.     public static String encodeToString(byte[] input, int flags) {
  455.         try {
  456.             return new String(encode(input, flags), "US-ASCII");
  457.         } catch (UnsupportedEncodingException e) {
  458.             // US-ASCII is guaranteed to be available.
  459.             throw new AssertionError(e);
  460.         }
  461.     }
  462.  
  463.     /**
  464.      * Base64-encode the given data and return a newly allocated
  465.      * String with the result.
  466.      *
  467.      * @param input  the data to encode
  468.      * @param offset the position within the input array at which to
  469.      *               start
  470.      * @param len    the number of bytes of input to encode
  471.      * @param flags  controls certain features of the encoded output.
  472.      *               Passing {@code DEFAULT} results in output that
  473.      *               adheres to RFC 2045.
  474.      */
  475.     public static String encodeToString(byte[] input, int offset, int len, int flags) {
  476.         try {
  477.             return new String(encode(input, offset, len, flags), "US-ASCII");
  478.         } catch (UnsupportedEncodingException e) {
  479.             // US-ASCII is guaranteed to be available.
  480.             throw new AssertionError(e);
  481.         }
  482.     }
  483.  
  484.     /**
  485.      * Base64-encode the given data and return a newly allocated
  486.      * byte[] with the result.
  487.      *
  488.      * @param input  the data to encode
  489.      * @param flags  controls certain features of the encoded output.
  490.      *               Passing {@code DEFAULT} results in output that
  491.      *               adheres to RFC 2045.
  492.      */
  493.     public static byte[] encode(byte[] input, int flags) {
  494.         return encode(input, 0, input.length, flags);
  495.     }
  496.  
  497.     /**
  498.      * Base64-encode the given data and return a newly allocated
  499.      * byte[] with the result.
  500.      *
  501.      * @param input  the data to encode
  502.      * @param offset the position within the input array at which to
  503.      *               start
  504.      * @param len    the number of bytes of input to encode
  505.      * @param flags  controls certain features of the encoded output.
  506.      *               Passing {@code DEFAULT} results in output that
  507.      *               adheres to RFC 2045.
  508.      */
  509.     public static byte[] encode(byte[] input, int offset, int len, int flags) {
  510.         Encoder encoder = new Encoder(flags, null);
  511.  
  512.         // Compute the exact length of the array we will produce.
  513.         int output_len = len / 3 * 4;
  514.  
  515.         // Account for the tail of the data and the padding bytes, if any.
  516.         if (encoder.do_padding) {
  517.             if (len % 3 > 0) {
  518.                 output_len += 4;
  519.             }
  520.         } else {
  521.             switch (len % 3) {
  522.                 case 0: break;
  523.                 case 1: output_len += 2; break;
  524.                 case 2: output_len += 3; break;
  525.             }
  526.         }
  527.  
  528.         // Account for the newlines, if any.
  529.         if (encoder.do_newline && len > 0) {
  530.             output_len += (((len-1) / (3 * Encoder.LINE_GROUPS)) + 1) *
  531.                 (encoder.do_cr ? 2 : 1);
  532.         }
  533.  
  534.         encoder.output = new byte[output_len];
  535.         encoder.process(input, offset, len, true);
  536.  
  537.         assert encoder.op == output_len;
  538.  
  539.         return encoder.output;
  540.     }
  541.  
  542.     /* package */ static class Encoder extends Coder {
  543.         /**
  544.          * Emit a new line every this many output tuples.  Corresponds to
  545.          * a 76-character line length (the maximum allowable according to
  546.          * <a href="http://www.ietf.org/rfc/rfc2045.txt">RFC 2045</a>).
  547.          */
  548.         public static final int LINE_GROUPS = 19;
  549.  
  550.         /**
  551.          * Lookup table for turning Base64 alphabet positions (6 bits)
  552.          * into output bytes.
  553.          */
  554.         private static final byte ENCODE[] = {
  555.             'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P',
  556.             'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z', 'a', 'b', 'c', 'd', 'e', 'f',
  557.             'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v',
  558.             'w', 'x', 'y', 'z', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '+', '/',
  559.         };
  560.  
  561.         /**
  562.          * Lookup table for turning Base64 alphabet positions (6 bits)
  563.          * into output bytes.
  564.          */
  565.         private static final byte ENCODE_WEBSAFE[] = {
  566.             'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P',
  567.             'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z', 'a', 'b', 'c', 'd', 'e', 'f',
  568.             'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v',
  569.             'w', 'x', 'y', 'z', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '-', '_',
  570.         };
  571.  
  572.         final private byte[] tail;
  573.         /* package */ int tailLen;
  574.         private int count;
  575.  
  576.         final public boolean do_padding;
  577.         final public boolean do_newline;
  578.         final public boolean do_cr;
  579.         final private byte[] alphabet;
  580.  
  581.         public Encoder(int flags, byte[] output) {
  582.             this.output = output;
  583.  
  584.             do_padding = (flags & NO_PADDING) == 0;
  585.             do_newline = (flags & NO_WRAP) == 0;
  586.             do_cr = (flags & CRLF) != 0;
  587.             alphabet = ((flags & URL_SAFE) == 0) ? ENCODE : ENCODE_WEBSAFE;
  588.  
  589.             tail = new byte[2];
  590.             tailLen = 0;
  591.  
  592.             count = do_newline ? LINE_GROUPS : -1;
  593.         }
  594.  
  595.         /**
  596.          * @return an overestimate for the number of bytes {@code
  597.          * len} bytes could encode to.
  598.          */
  599.         public int maxOutputSize(int len) {
  600.             return len * 8/5 + 10;
  601.         }
  602.  
  603.         public boolean process(byte[] input, int offset, int len, boolean finish) {
  604.             // Using local variables makes the encoder about 9% faster.
  605.             final byte[] alphabet = this.alphabet;
  606.             final byte[] output = this.output;
  607.             int op = 0;
  608.             int count = this.count;
  609.  
  610.             int p = offset;
  611.             len += offset;
  612.             int v = -1;
  613.  
  614.             // First we need to concatenate the tail of the previous call
  615.             // with any input bytes available now and see if we can empty
  616.             // the tail.
  617.  
  618.             switch (tailLen) {
  619.                 case 0:
  620.                     // There was no tail.
  621.                     break;
  622.  
  623.                 case 1:
  624.                     if (p+2 <= len) {
  625.                         // A 1-byte tail with at least 2 bytes of
  626.                         // input available now.
  627.                         v = ((tail[0] & 0xff) << 16) |
  628.                             ((input[p++] & 0xff) << 8) |
  629.                             (input[p++] & 0xff);
  630.                         tailLen = 0;
  631.                     };
  632.                     break;
  633.  
  634.                 case 2:
  635.                     if (p+1 <= len) {
  636.                         // A 2-byte tail with at least 1 byte of input.
  637.                         v = ((tail[0] & 0xff) << 16) |
  638.                             ((tail[1] & 0xff) << 8) |
  639.                             (input[p++] & 0xff);
  640.                         tailLen = 0;
  641.                     }
  642.                     break;
  643.             }
  644.  
  645.             if (v != -1) {
  646.                 output[op++] = alphabet[(v >> 18) & 0x3f];
  647.                 output[op++] = alphabet[(v >> 12) & 0x3f];
  648.                 output[op++] = alphabet[(v >> 6) & 0x3f];
  649.                 output[op++] = alphabet[v & 0x3f];
  650.                 if (--count == 0) {
  651.                     if (do_cr) output[op++] = '\r';
  652.                     output[op++] = '\n';
  653.                     count = LINE_GROUPS;
  654.                 }
  655.             }
  656.  
  657.             // At this point either there is no tail, or there are fewer
  658.             // than 3 bytes of input available.
  659.  
  660.             // The main loop, turning 3 input bytes into 4 output bytes on
  661.             // each iteration.
  662.             while (p+3 <= len) {
  663.                 v = ((input[p] & 0xff) << 16) |
  664.                     ((input[p+1] & 0xff) << 8) |
  665.                     (input[p+2] & 0xff);
  666.                 output[op] = alphabet[(v >> 18) & 0x3f];
  667.                 output[op+1] = alphabet[(v >> 12) & 0x3f];
  668.                 output[op+2] = alphabet[(v >> 6) & 0x3f];
  669.                 output[op+3] = alphabet[v & 0x3f];
  670.                 p += 3;
  671.                 op += 4;
  672.                 if (--count == 0) {
  673.                     if (do_cr) output[op++] = '\r';
  674.                     output[op++] = '\n';
  675.                     count = LINE_GROUPS;
  676.                 }
  677.             }
  678.  
  679.             if (finish) {
  680.                 // Finish up the tail of the input.  Note that we need to
  681.                 // consume any bytes in tail before any bytes
  682.                 // remaining in input; there should be at most two bytes
  683.                 // total.
  684.  
  685.                 if (p-tailLen == len-1) {
  686.                     int t = 0;
  687.                     v = ((tailLen > 0 ? tail[t++] : input[p++]) & 0xff) << 4;
  688.                     tailLen -= t;
  689.                     output[op++] = alphabet[(v >> 6) & 0x3f];
  690.                     output[op++] = alphabet[v & 0x3f];
  691.                     if (do_padding) {
  692.                         output[op++] = '=';
  693.                         output[op++] = '=';
  694.                     }
  695.                     if (do_newline) {
  696.                         if (do_cr) output[op++] = '\r';
  697.                         output[op++] = '\n';
  698.                     }
  699.                 } else if (p-tailLen == len-2) {
  700.                     int t = 0;
  701.                     v = (((tailLen > 1 ? tail[t++] : input[p++]) & 0xff) << 10) |
  702.                         (((tailLen > 0 ? tail[t++] : input[p++]) & 0xff) << 2);
  703.                     tailLen -= t;
  704.                     output[op++] = alphabet[(v >> 12) & 0x3f];
  705.                     output[op++] = alphabet[(v >> 6) & 0x3f];
  706.                     output[op++] = alphabet[v & 0x3f];
  707.                     if (do_padding) {
  708.                         output[op++] = '=';
  709.                     }
  710.                     if (do_newline) {
  711.                         if (do_cr) output[op++] = '\r';
  712.                         output[op++] = '\n';
  713.                     }
  714.                 } else if (do_newline && op > 0 && count != LINE_GROUPS) {
  715.                     if (do_cr) output[op++] = '\r';
  716.                     output[op++] = '\n';
  717.                 }
  718.  
  719.                 assert tailLen == 0;
  720.                 assert p == len;
  721.             } else {
  722.                 // Save the leftovers in tail to be consumed on the next
  723.                 // call to encodeInternal.
  724.  
  725.                 if (p == len-1) {
  726.                     tail[tailLen++] = input[p];
  727.                 } else if (p == len-2) {
  728.                     tail[tailLen++] = input[p];
  729.                     tail[tailLen++] = input[p+1];
  730.                 }
  731.             }
  732.  
  733.             this.op = op;
  734.             this.count = count;
  735.  
  736.             return true;
  737.         }
  738.     }
  739.  
  740.     private Base64() { }   // don't instantiate
  741. }
  1. package ghj1976.Demo;
  2.  
  3. import javax.crypto.Cipher;
  4. import javax.crypto.SecretKey;
  5. import javax.crypto.SecretKeyFactory;
  6. import javax.crypto.spec.DESKeySpec;
  7. import javax.crypto.spec.IvParameterSpec;
  8.  
  9. public class DES {
  10. 	 private static String DESKey = "12345678"; // 字节数必须是8的倍数
  11. 	 private static byte[] iv1 = {(byte)0x12, (byte)0x34, (byte)0x56, (byte)0x78, (byte)0x90, (byte)0xAB, (byte)0xCD, (byte)0xEF};
  12. 	 public static void main(String[] args) {
  13. 		 System.out.print("xyz");
  14. 		DES des = new DES();
  15. 		System.out.print(des.encrypt("19760519"));
  16. 	}
  17. 	 public byte[] desEncrypt(byte[] plainText) throws Exception
  18. 	    {
  19. //	        SecureRandom sr = new SecureRandom();
  20. //	        sr.setSeed(iv);
  21.  
  22. //	    	 IvParameterSpec iv = new IvParameterSpec(key.getBytes("UTF-8"));
  23. 	    	IvParameterSpec iv = new IvParameterSpec(iv1);
  24.  
  25. 	        DESKeySpec dks = new DESKeySpec(DESKey.getBytes());
  26. 	        SecretKeyFactory keyFactory = SecretKeyFactory.getInstance("DES");
  27. 	        SecretKey key = keyFactory.generateSecret(dks);
  28. 	        Cipher cipher = Cipher.getInstance("DES/CBC/PKCS5Padding");
  29. 	        cipher.init(Cipher.ENCRYPT_MODE, key, iv);
  30. 	        byte data[] = plainText;
  31. 	        byte encryptedData[] = cipher.doFinal(data);
  32. 	        return encryptedData;
  33. 	    }  
  34.  
  35. 	    public String encrypt(String input)
  36. 	    {
  37. 	    	String result = "input";
  38. 	        try {
  39. 				result = base64Encode(desEncrypt(input.getBytes()));
  40. 			} catch (Exception e) {
  41. 				// TODO Auto-generated catch block
  42. 				e.printStackTrace();
  43. 			}
  44. 			return result;
  45. 	    }  
  46.  
  47. 	    public  String base64Encode(byte[] s)
  48. 	    {
  49. 	        if (s == null)
  50. 	            return null;
  51. 	        return Base64.encodeToString(s, Base64.DEFAULT);
  52.  
  53. 	    }
  54. }

Object c 的加解密函数

  1. //
  2. //  Utility.h
  3. //  TheDealersForum
  4. //
  5. //  Created by Hailong Zhang on 5/3/11.
  6. //  Copyright 2011 Personal. All rights reserved.
  7. //
  8.  
  9. #import <Foundation/Foundation.h>
  10. #import <CommonCrypto/CommonDigest.h>
  11. #import <CommonCrypto/CommonCryptor.h>
  12.  
  13. @interface Utility : NSObject {
  14.  
  15. }
  16. + (NSString *) udid;
  17. + (NSString *) md5:(NSString *)str;
  18. + (NSString *) doCipher:(NSString *)sTextIn key:(NSString *)sKey context:(CCOperation)encryptOrDecrypt;
  19. + (NSString *) encryptStr:(NSString *) str;
  20. + (NSString *) decryptStr:(NSString	*) str;
  21.  
  22. #pragma mark Based64
  23. + (NSString *) encodeBase64WithString:(NSString *)strData;
  24. + (NSString *) encodeBase64WithData:(NSData *)objData;
  25. + (NSData *) decodeBase64WithString:(NSString *)strBase64;
  26.  
  27. @end
  1. //
  2. //  Utility.m
  3. //  TheDealersForum
  4. //
  5. //  Created by Hailong Zhang on 5/3/11.
  6. //  Copyright 2011 Personal. All rights reserved.
  7. //
  8.  
  9. #import "Utility.h"
  10. static NSString *_key = @"12345678";
  11.  
  12. static const char _base64EncodingTable[64] = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
  13. static const short _base64DecodingTable[256] = {
  14. 	-2, -2, -2, -2, -2, -2, -2, -2, -2, -1, -1, -2, -1, -1, -2, -2,
  15. 	-2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2,
  16. 	-1, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, 62, -2, -2, -2, 63,
  17. 	52, 53, 54, 55, 56, 57, 58, 59, 60, 61, -2, -2, -2, -2, -2, -2,
  18. 	-2,  0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14,
  19. 	15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, -2, -2, -2, -2, -2,
  20. 	-2, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40,
  21. 	41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, -2, -2, -2, -2, -2,
  22. 	-2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2,
  23. 	-2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2,
  24. 	-2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2,
  25. 	-2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2,
  26. 	-2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2,
  27. 	-2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2,
  28. 	-2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2,
  29. 	-2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2
  30. };
  31.  
  32. @implementation Utility
  33. + (NSString *) udid
  34. {
  35. 	return [Utility encryptStr:[[UIDevice currentDevice] uniqueIdentifier]];
  36. }
  37. + (NSString *) md5:(NSString *)str
  38.  
  39. {
  40.  
  41. 	const char *cStr = [str UTF8String];
  42.  
  43. 	unsigned char result[CC_MD5_DIGEST_LENGTH];
  44.  
  45. 	CC_MD5( cStr, strlen(cStr), result );
  46.  
  47. 	return [NSString 
  48.  
  49. 			stringWithFormat: @"%02X%02X%02X%02X%02X%02X%02X%02X%02X%02X%02X%02X%02X%02X%02X%02X",
  50.  
  51. 			result[0], result[1],
  52.  
  53. 			result[2], result[3],
  54.  
  55. 			result[4], result[5],
  56.  
  57. 			result[6], result[7],
  58.  
  59. 			result[8], result[9],
  60.  
  61. 			result[10], result[11],
  62.  
  63. 			result[12], result[13],
  64.  
  65. 			result[14], result[15]
  66.  
  67. 			];
  68.  
  69. }
  70. + (NSString *) encryptStr:(NSString *) str
  71. {
  72. 	return [Utility doCipher:str key:_key context:kCCEncrypt];
  73. }
  74. + (NSString *) decryptStr:(NSString	*) str
  75. {
  76. 	return [Utility doCipher:str key:_key context:kCCDecrypt];
  77. }
  78. + (NSString *)doCipher:(NSString *)sTextIn key:(NSString *)sKey
  79. 			   context:(CCOperation)encryptOrDecrypt {
  80. 	NSStringEncoding EnC = NSUTF8StringEncoding;
  81.  
  82.     NSMutableData * dTextIn;
  83.     if (encryptOrDecrypt == kCCDecrypt) {
  84.         dTextIn = [[Utility decodeBase64WithString:sTextIn] mutableCopy];
  85.     }
  86.     else{
  87.         dTextIn = [[sTextIn dataUsingEncoding: EnC] mutableCopy];
  88.     }
  89.     NSMutableData * dKey = [[sKey dataUsingEncoding:EnC] mutableCopy];
  90.     [dKey setLength:kCCBlockSizeDES];
  91.     uint8_t *bufferPtr1 = NULL;
  92.     size_t bufferPtrSize1 = 0;
  93.     size_t movedBytes1 = 0;
  94.     //uint8_t iv[kCCBlockSizeDES];
  95. 	//memset((void *) iv, 0x0, (size_t) sizeof(iv));
  96. 	Byte iv[] = {0x12, 0x34, 0x56, 0x78, 0x90, 0xAB, 0xCD, 0xEF};
  97.     bufferPtrSize1 = ([sTextIn length] + kCCKeySizeDES) & ~(kCCKeySizeDES -1);
  98.     bufferPtr1 = malloc(bufferPtrSize1 * sizeof(uint8_t));
  99.     memset((void *)bufferPtr1, 0x00, bufferPtrSize1);
  100. 	CCCrypt(encryptOrDecrypt, // CCOperation op
  101. 			kCCAlgorithmDES, // CCAlgorithm alg
  102. 			kCCOptionPKCS7Padding, // CCOptions options
  103. 			[dKey bytes], // const void *key
  104. 			[dKey length], // size_t keyLength
  105. 			iv, // const void *iv
  106. 			[dTextIn bytes], // const void *dataIn
  107. 			[dTextIn length],  // size_t dataInLength
  108. 			(void *)bufferPtr1, // void *dataOut
  109. 			bufferPtrSize1,     // size_t dataOutAvailable
  110. 			&movedBytes1);      // size_t *dataOutMoved    
  111.  
  112.     NSString * sResult;
  113.     if (encryptOrDecrypt == kCCDecrypt){
  114.         sResult = [[[ NSString alloc] initWithData:[NSData dataWithBytes:bufferPtr1
  115. 																  length:movedBytes1] encoding:EnC] autorelease];
  116.     }
  117.     else {
  118.         NSData *dResult = [NSData dataWithBytes:bufferPtr1 length:movedBytes1];
  119.         sResult = [Utility encodeBase64WithData:dResult];
  120.     }
  121.     return sResult;
  122. }
  123.  
  124. + (NSString *)encodeBase64WithString:(NSString *)strData {
  125. 	return [Utility encodeBase64WithData:[strData dataUsingEncoding:NSUTF8StringEncoding]];
  126. }
  127.  
  128. + (NSString *)encodeBase64WithData:(NSData *)objData {
  129. 	const unsigned char * objRawData = [objData bytes];
  130. 	char * objPointer;
  131. 	char * strResult;
  132.  
  133. 	// Get the Raw Data length and ensure we actually have data
  134. 	int intLength = [objData length];
  135. 	if (intLength == 0) return nil;
  136.  
  137. 	// Setup the String-based Result placeholder and pointer within that placeholder
  138. 	strResult = (char *)calloc(((intLength + 2) / 3) * 4, sizeof(char));
  139. 	objPointer = strResult;
  140.  
  141. 	// Iterate through everything
  142. 	while (intLength > 2) { // keep going until we have less than 24 bits
  143. 		*objPointer++ = _base64EncodingTable[objRawData[0] >> 2];
  144. 		*objPointer++ = _base64EncodingTable[((objRawData[0] & 0x03) << 4) + (objRawData[1] >> 4)];
  145. 		*objPointer++ = _base64EncodingTable[((objRawData[1] & 0x0f) << 2) + (objRawData[2] >> 6)];
  146. 		*objPointer++ = _base64EncodingTable[objRawData[2] & 0x3f];
  147.  
  148. 		// we just handled 3 octets (24 bits) of data
  149. 		objRawData += 3;
  150. 		intLength -= 3;
  151. 	}
  152.  
  153. 	// now deal with the tail end of things
  154. 	if (intLength != 0) {
  155. 		*objPointer++ = _base64EncodingTable[objRawData[0] >> 2];
  156. 		if (intLength > 1) {
  157. 			*objPointer++ = _base64EncodingTable[((objRawData[0] & 0x03) << 4) + (objRawData[1] >> 4)];
  158. 			*objPointer++ = _base64EncodingTable[(objRawData[1] & 0x0f) << 2];
  159. 			*objPointer++ = '=';
  160. 		} else {
  161. 			*objPointer++ = _base64EncodingTable[(objRawData[0] & 0x03) << 4];
  162. 			*objPointer++ = '=';
  163. 			*objPointer++ = '=';
  164. 		}
  165. 	}
  166.  
  167. 	// Terminate the string-based result
  168. 	*objPointer = '\0';
  169.  
  170. 	// Return the results as an NSString object
  171. 	return [NSString stringWithCString:strResult encoding:NSASCIIStringEncoding];
  172. }
  173.  
  174. + (NSData *)decodeBase64WithString:(NSString *)strBase64 {
  175. 	const char * objPointer = [strBase64 cStringUsingEncoding:NSASCIIStringEncoding];
  176. 	int intLength = strlen(objPointer);
  177. 	int intCurrent;
  178. 	int i = 0, j = 0, k;
  179.  
  180. 	unsigned char * objResult;
  181. 	objResult = calloc(intLength, sizeof(char));
  182.  
  183. 	// Run through the whole string, converting as we go
  184. 	while ( ((intCurrent = *objPointer++) != '\0') && (intLength-- > 0) ) {
  185. 		if (intCurrent == '=') {
  186. 			if (*objPointer != '=' && ((i % 4) == 1)) {// || (intLength > 0)) {
  187. 				// the padding character is invalid at this point -- so this entire string is invalid
  188. 				free(objResult);
  189. 				return nil;
  190. 			}
  191. 			continue;
  192. 		}
  193.  
  194. 		intCurrent = _base64DecodingTable[intCurrent];
  195. 		if (intCurrent == -1) {
  196. 			// we're at a whitespace -- simply skip over
  197. 			continue;
  198. 		} else if (intCurrent == -2) {
  199. 			// we're at an invalid character
  200. 			free(objResult);
  201. 			return nil;
  202. 		}
  203.  
  204. 		switch (i % 4) {
  205. 			case 0:
  206. 				objResult[j] = intCurrent << 2;
  207. 				break;
  208.  
  209. 			case 1:
  210. 				objResult[j++] |= intCurrent >> 4;
  211. 				objResult[j] = (intCurrent & 0x0f) << 4;
  212. 				break;
  213.  
  214. 			case 2:
  215. 				objResult[j++] |= intCurrent >>2;
  216. 				objResult[j] = (intCurrent & 0x03) << 6;
  217. 				break;
  218.  
  219. 			case 3:
  220. 				objResult[j++] |= intCurrent;
  221. 				break;
  222. 		}
  223. 		i++;
  224. 	}
  225.  
  226. 	// mop things up if we ended on a boundary
  227. 	k = j;
  228. 	if (intCurrent == '=') {
  229. 		switch (i % 4) {
  230. 			case 1:
  231. 				// Invalid state
  232. 				free(objResult);
  233. 				return nil;
  234.  
  235. 			case 2:
  236. 				k++;
  237. 				// flow through
  238. 			case 3:
  239. 				objResult[k] = 0;
  240. 		}
  241. 	}
  242.  
  243. 	// Cleanup and setup the return NSData
  244. 	NSData * objData = [[[NSData alloc] initWithBytes:objResult length:j] autorelease];
  245. 	free(objResult);
  246. 	return objData;
  247. }
  248. @end

DES加密和解密PHP，Java，ObjectC统一的方法的更多相关文章

  1. 【Java】通过DES加密和解密工具，对字符串进行加密和解密操作

    分享一个非常不错的字符串加密和解密的程序. 可以指定不同的密钥对同一字符串进行不同的加密操作,增强加密性能. Java代码如下: package com.app; import java.securi ...

  2. Java Base64加密、解密原理Java代码

    Java Base64加密.解密原理Java代码 转自:http://blog.csdn.net/songylwq/article/details/7578905 Base64是什么: Base64是 ...

  3. 一、DES加密和解密

    一.DES加密和解密 原文:http://www.jb51.net/article/51879.htm  还有其他文章 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 1 ...

  4. DES加密与解密在GET请求时解密失败的问题

    DES加密与解密在GET请求时解密失败的问题 在数据进行加密后传递会更安全,但可能有个问题:就是Url编码问题,如果不对Url进行编码直接加密,那么在解密时,如果字符串存在 “+”,这种特殊符号,在解 ...

  5. java实现DES加密与解密，md5加密

    很多时候要对秘要进行持久化加密,此时的加密采用md5.采用对称加密的时候就采用DES方法了 import java.io.IOException; import java.security.Messa ...

  6. Java DES 加密和解密源码（转）

    原文地址:http://www.oschina.net/code/snippet_727646_18383 Java密码学结构设计遵循两个原则: 1) 算法的独立性和可靠性. 2) 实现的独立性和相互 ...

  7. .Net使用DES加密，.Net和java分别解密，并正则匹配替换加密密码为明文

    在VS中用WindowsApplication做一个exe程序,用来给数据库密码加密,加密代码如下 private void generateBtn_Click(object sender, Even ...

  8. PHP 识别 java 8位 des 加密和 解密方式

    代码及使用说明: <?php /** *PHP 识别 java 8位密钥的加密和解密方式 *@desc 加密方式 通用 */ class DES { var $key; var $iv; //偏 ...

  9. BASE64,MD5,SHA,HMAC加密與解密算法(java)

    package com.ice.webos.util.security; import java.io.UnsupportedEncodingException; import java.math.B ...

随机推荐

  1. C#读取excel等表格常用方法

    0. 利用NPOI. 请查阅此插件的相关文档. 1.方法一:采用OleDB读取EXCEL文件: 把EXCEL文件当做一个数据源来进行数据的读取操作,实例如下: 1 2 3 4 5 6 7 8 9 10 ...

  2. ZOJ 3734 LIKE vs CANDLE

    题目意思:(13年长沙站的一道水DP,本人也去了,当时太水笔) 说俩个人竞争选票,每个人可以随机选择支持谁.每个人带有权重不同. 现在已经结束了投票阶段,你一个骇客 支持LIKE  你写了一个软件可以 ...

  3. ps命令用法详解（转）

    ps p 22763  -L -o pcpu,pid,tid,time,tname,cmd,pmem,rss --sort rss  按rss排序 ps p 26653 -L -o pcpu,tid ...

  4. UVA434 - Matty&#39;s Blocks

    option=com_onlinejudge&Itemid=8&page=show_problem&category=457&problem=375&mosms ...

  5. 如何插上U盘 自动复制内容

    U盘插入自动复制,有效对付那些不肯给PPT的老师,还有一定几率拿到期末考试卷子···有图有真相!业界良心的好东西!!现在看还来得及!!! 代码优化了一下,把不是很重要的都删掉了,这次使用时看不出任何现 ...

  6. 【C语言探索之旅】 第二部分第九课： 实战"悬挂小人"游戏 答案

    内容简介 1.课程大纲 2.第二部分第九课: 实战"悬挂小人"游戏 答案 3.第二部分第十课预告: 安全的文本输入 课程大纲 我们的课程分为四大部分,每一个部分结束后都会有练习题, ...

  7. redis源代码解读之内存管理————zmalloc文件

    本文章主要记录本人在看redis源代码的一些理解和想法.由于功力有限,肯定会出现故障,所以.希望高手给出指正. 第一篇就是内存相关的介绍.由于我喜欢先看一些组件的东西,再看总体的流程. 先上一下代码吧 ...

  8. RunJS推荐用于个人使用（使用方便JS、css实时预览、编辑、管理等功能）

    RunJS,在线编写.展示html.js.css代码,拥有实时预览.分享.Fork.代码高亮.自己主动完毕等多项特性,提供文件上传.多种登录方式. 地址:http://runjs.cn/ waterm ...

  9. yate.conf

    但档案.粘贴下面的例子.不解释!除去非常灵活!只保留sip电话! [general] ; General settings for the operation of Yate ; modload: b ...

  10. C# WinForm 拖动无边框窗体 改变无边框窗体尺寸

    经常遇到这种情况.窗体的边框去掉了.然后种种问题就出来了:不能拖动.不能改变窗体大小.不能．．．．．．当然.肯定有解决方案滴*^_^*今天的目标就是:可以直接拖动没有边框的窗体.可以直接拉拽窗体改变其 ...